diff --git a/cvs/cli_plugins/run_plugin.py b/cvs/cli_plugins/run_plugin.py
index 72a8c8d1..ab9936b0 100644
--- a/cvs/cli_plugins/run_plugin.py
+++ b/cvs/cli_plugins/run_plugin.py
@@ -23,8 +23,12 @@ def get_parser(self, subparsers):
         )
         parser.add_argument(
             "--log-file",
-            default="/tmp/cvs/test.log",
-            help="Pytest: Path to file for logging output (default: /tmp/cvs/test.log)",
+            default=None,
+            metavar="PATH",
+            help=(
+                "Pytest: write logging output to this file (optional). "
+                "Parent directories are created automatically when set."
+            ),
         )
         parser.add_argument(
             "--log-level",
diff --git a/cvs/cli_plugins/unittests/test_run_plugin.py b/cvs/cli_plugins/unittests/test_run_plugin.py
index ef73ad42..57fbfa1a 100644
--- a/cvs/cli_plugins/unittests/test_run_plugin.py
+++ b/cvs/cli_plugins/unittests/test_run_plugin.py
@@ -79,6 +79,35 @@ def test_run_test_multiple_functions(self, mock_exit, mock_pytest_main):
         mock_pytest_main.assert_called_once_with(expected_args)
         mock_exit.assert_called_once_with(0)
 
+    @patch("cvs.cli_plugins.run_plugin.pytest.main")
+    @patch("cvs.cli_plugins.run_plugin.sys.exit")
+    def test_run_test_omits_log_file_when_not_set(self, mock_exit, mock_pytest_main):
+        """No --log-file is passed to pytest when the user does not request file logging."""
+        args = MagicMock()
+        args.test = "agfhc_cvs"
+        args.function = []
+        args.cluster_file = "/path/to/cluster.json"
+        args.config_file = "/path/to/config.json"
+        args.html = None
+        args.self_contained_html = False
+        args.log_file = None
+        args.log_level = None
+        args.capture = None
+        args.extra_pytest_args = []
+
+        mock_pytest_main.return_value = 0
+
+        with patch.object(self.plugin, "get_test_file", return_value="/mock/path/test.py"):
+            self.plugin.run(args)
+
+        expected_args = [
+            "/mock/path/test.py",
+            "--cluster_file=/path/to/cluster.json",
+            "--config_file=/path/to/config.json",
+        ]
+        mock_pytest_main.assert_called_once_with(expected_args)
+        mock_exit.assert_called_once_with(0)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/cvs/input/cluster_file/mi300x_vllm_single.json b/cvs/input/cluster_file/mi300x_vllm_single.json
deleted file mode 100644
index e2096212..00000000
--- a/cvs/input/cluster_file/mi300x_vllm_single.json
+++ /dev/null
@@ -1,33 +0,0 @@
-{
-    "_comment": "Single-node MI300X cluster for the vllm_single PoC verification. Container backend with launch:true so CVS owns the container lifecycle; the actual image+name come from the variant config.json (container block), with this file providing only the cluster portion (node/user/key). Replace every <changeme> with your node/deployment specifics before running.",
-
-    "orchestrator": "container",
-    "username": "{user-id}",
-    "priv_key_file": "/data/{user-id}/.ssh/id_ed25519",
-
-    "head_node_dict": {
-        "mgmt_ip": "<changeme>"
-    },
-    "env_vars": {},
-    "node_dict": {
-        "<changeme>": {
-            "bmc_ip": "NA",
-            "vpc_ip": "<changeme>"
-        }
-    },
-
-    "_container_comment": "Stub container block; the testsuite config (variant config.json) overrides image/name/runtime.args via OrchestratorConfig.from_configs.",
-    "container": {
-        "lifetime": "per_run",
-        "name": "<changeme>",
-        "image": "<changeme>",
-        "runtime": {
-            "name": "docker",
-            "args": {
-                "network": "host",
-                "ipc": "host",
-                "privileged": true
-            }
-        }
-    }
-}
diff --git a/cvs/input/config_file/inference/inferencemax/mi300x_inferencemax_gpt_oss_120b_single.json b/cvs/input/config_file/inference/inferencemax/mi300x_inferencemax_gpt_oss_120b_single.json
deleted file mode 100644
index 18a4d5a8..00000000
--- a/cvs/input/config_file/inference/inferencemax/mi300x_inferencemax_gpt_oss_120b_single.json
+++ /dev/null
@@ -1,54 +0,0 @@
-{
-    "config": {
-        "container_image": "rocm/7.0:rocm7.0_ubuntu_22.04_vllm_0.10.1_instinct_20250927_rc1",
-        "container_name": "inference_max_rocm",
-        "_example_nnodes": "4",
-        "nnodes": "4",
-        "inferencemax_repo": "https://github.com/SemiAnalysisAI/InferenceX.git",
-        "benchmark_script_repo": "https://github.com/kimbochen/bench_serving.git",
-        "hf_token_file": "/home/{user-id}/.hf_token",
-        "shm_size": "128G",
-        "log_dir": "/home/{user-id}/LOGS",
-        "container_config": {
-            "device_list": [
-                "/dev/dri",
-                "/dev/kfd"
-            ],
-            "volume_dict": {
-                "/home/{user-id}": "/home/{user-id}"
-            },
-            "env_dict": {}
-        }
-    },
-    "benchmark_params": {
-        "gpt-oss-120b": {
-            "backend": "vllm",
-            "base_url": "http://0.0.0.0",
-            "port_no": "8000",
-            "_example_dataset_name": "sharegpt|hf|random|sonnet|burstgpt",
-            "dataset_name": "random",
-            "max_concurrency": "64",
-            "model": "openai/gpt-oss-120b",
-            "num_prompts": "1000",
-            "input_sequence_length": "8192",
-            "output_sequence_length": "1024",
-            "burstiness": "1.0",
-            "seed": "0",
-            "max_model_length": "9216",
-            "random_range_ratio": "0.8",
-            "random_prefix_len": "0",
-            "tensor_parallelism": "8",
-            "_example_tokenizer_mode": "auto|slow|mistral|custom",
-            "tokenizer_mode": "auto",
-            "percentiles_metrics": "ttft,tpot,itl,e2el",
-            "metric_percentiles": "99",
-            "server_script": "gptoss_fp4_mi300x.sh",
-            "bench_serv_script": "benchmark_serving.py",
-            "result_dict": {
-                "output_throughput_per_sec": "4200",
-                "mean_ttft_ms": "500",
-                "mean_tpot_ms": "15"
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/cvs/input/config_file/inference/inferencemax/mi355x_inferencemax_gpt_oss_120b_single.json b/cvs/input/config_file/inference/inferencemax/mi355x_inferencemax_gpt_oss_120b_single.json
deleted file mode 100644
index 516efca2..00000000
--- a/cvs/input/config_file/inference/inferencemax/mi355x_inferencemax_gpt_oss_120b_single.json
+++ /dev/null
@@ -1,54 +0,0 @@
-{
-    "config": {
-        "container_image": "rocm/7.0:rocm7.0_ubuntu_22.04_vllm_0.10.1_instinct_20250927_rc1",
-        "container_name": "inference_max_rocm",
-        "_example_nnodes": "4",
-        "nnodes": "4",
-        "inferencemax_repo": "https://github.com/SemiAnalysisAI/InferenceX.git",
-        "benchmark_script_repo": "https://github.com/kimbochen/bench_serving.git",
-        "hf_token_file": "/home/{user-id}/.hf_token",
-        "shm_size": "128G",
-        "log_dir": "/home/{user-id}/LOGS",
-        "container_config": {
-            "device_list": [
-                "/dev/dri",
-                "/dev/kfd"
-            ],
-            "volume_dict": {
-                "/home/{user-id}": "/home/{user-id}"
-            },
-            "env_dict": {}
-        }
-    },
-    "benchmark_params": {
-        "gpt-oss-120b": {
-            "backend": "vllm",
-            "base_url": "http://0.0.0.0",
-            "port_no": "8000",
-            "_example_dataset_name": "sharegpt|hf|random|sonnet|burstgpt",
-            "dataset_name": "random",
-            "max_concurrency": "64",
-            "model": "openai/gpt-oss-120b",
-            "num_prompts": "1000",
-            "input_sequence_length": "8192",
-            "output_sequence_length": "1024",
-            "burstiness": "1.0",
-            "seed": "0",
-            "max_model_length": "9216",
-            "random_range_ratio": "0.8",
-            "random_prefix_len": "0",
-            "tensor_parallelism": "8",
-            "_example_tokenizer_mode": "auto|slow|mistral|custom",
-            "tokenizer_mode": "auto",
-            "percentiles_metrics": "ttft,tpot,itl,e2el",
-            "metric_percentiles": "99",
-            "server_script": "gptoss_fp4_mi355x.sh",
-            "bench_serv_script": "benchmark_serving.py",
-            "result_dict": {
-                "output_throughput_per_sec": "4200",
-                "mean_ttft_ms": "500",
-                "mean_tpot_ms": "15"
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/cvs/input/config_file/inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_config.json b/cvs/input/config_file/inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_config.json
new file mode 100644
index 00000000..9e30b8c0
--- /dev/null
+++ b/cvs/input/config_file/inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_config.json
@@ -0,0 +1,89 @@
+{
+  "_comment": "Single-node InferenceMax (schema_version 1). Set container.image and container.name. ISL+OSL must fit params.max_model_length. Volume bind home only; ContainerOrchestrator adds /home/<user>:/workspace.",
+  "schema_version": 1,
+  "framework": "inferencemax_single",
+  "gpu_arch": "mi300x",
+  "enforce_thresholds": false,
+  "paths": {
+    "shared_fs": "/home/{user-id}",
+    "models_dir": "{shared_fs}/models",
+    "log_dir": "{shared_fs}/LOGS",
+    "hf_token_file": "{shared_fs}/.hf_token"
+  },
+  "model": {
+    "id": "openai/gpt-oss-120b",
+    "remote": 0,
+    "precision": "bf16"
+  },
+  "container": {
+    "lifetime": "per_run",
+    "name": "<changeme>",
+    "image": "<changeme>",
+    "runtime": {
+      "name": "docker",
+      "args": {
+        "network": "host",
+        "ipc": "host",
+        "privileged": true,
+        "shm_size": "128G",
+        "volumes": [
+          "/home/{user-id}:/home/{user-id}"
+        ],
+        "devices": [
+          "/dev/dri",
+          "/dev/kfd"
+        ]
+      }
+    }
+  },
+  "roles": {
+    "server": {
+      "serve_args": {
+        "enforce-eager": true,
+        "gpu-memory-utilization": "0.95",
+        "block-size": 64,
+        "no-enable-prefix-caching": true
+      },
+      "env": {
+        "AMDGCN_USE_BUFFER_OPS": "0",
+        "VLLM_ROCM_USE_AITER": "1",
+        "VLLM_ROCM_QUICK_REDUCE_QUANTIZATION": "INT4"
+      }
+    }
+  },
+  "params": {
+    "backend": "vllm",
+    "base_url": "http://0.0.0.0",
+    "port_no": "8000",
+    "dataset_name": "random",
+    "burstiness": "1.0",
+    "seed": "0",
+    "request_rate": "inf",
+    "random_range_ratio": "0.8",
+    "random_prefix_len": "0",
+    "tensor_parallelism": "8",
+    "tokenizer_mode": "auto",
+    "percentile_metrics": "ttft,tpot,itl,e2el",
+    "metric_percentiles": "99",
+    "num_prompts": "1000",
+    "max_model_length": "8192",
+    "client_poll_count": "50",
+    "client_poll_wait_time": "60",
+    "bench_max_failed_requests": "0"
+  },
+  "sweep": {
+    "sequence_combinations": [
+      {
+        "name": "legacy_profile",
+        "isl": "7168",
+        "osl": "1024"
+      }
+    ],
+    "runs": [
+      {
+        "combo": "legacy_profile",
+        "concurrency": 64
+      }
+    ]
+  }
+}
diff --git a/cvs/input/config_file/inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_threshold.json b/cvs/input/config_file/inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_threshold.json
new file mode 100644
index 00000000..aeea7717
--- /dev/null
+++ b/cvs/input/config_file/inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_threshold.json
@@ -0,0 +1,97 @@
+{
+  "_comment": "client.* thresholds for ISL=7168,OSL=1024,TP=8,CONC=64. Every GATED_METRICS member has a spec so the loader coverage check passes. config.json sets enforce_thresholds=false until calibrated; output_throughput/mean_ttft_ms/mean_tpot_ms carry legacy verify_inference_results targets.",
+  "ISL=7168,OSL=1024,TP=8,CONC=64": {
+    "client.total_token_throughput": {
+      "kind": "min_tok_s",
+      "value": 0
+    },
+    "client.output_throughput": {
+      "kind": "min_tok_s",
+      "value": 4200
+    },
+    "client.mean_ttft_ms": {
+      "kind": "max_ms",
+      "value": 500
+    },
+    "client.median_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_tpot_ms": {
+      "kind": "max_ms",
+      "value": 15
+    },
+    "client.median_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.median_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.median_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.success_rate": {
+      "kind": "min",
+      "value": 0
+    },
+    "client.failed": {
+      "kind": "max",
+      "value": 1000000000
+    }
+  }
+}
diff --git a/cvs/input/config_file/inference/inferencemax_single/mi355x_inferencemax_gpt_oss_120b_single/mi355x_inferencemax_gpt_oss_120b_single_config.json b/cvs/input/config_file/inference/inferencemax_single/mi355x_inferencemax_gpt_oss_120b_single/mi355x_inferencemax_gpt_oss_120b_single_config.json
new file mode 100644
index 00000000..211084f5
--- /dev/null
+++ b/cvs/input/config_file/inference/inferencemax_single/mi355x_inferencemax_gpt_oss_120b_single/mi355x_inferencemax_gpt_oss_120b_single_config.json
@@ -0,0 +1,85 @@
+{
+  "_comment": "Single-node InferenceMax sample (schema_version 1). Set container.image and container.name. Verify server_script against your InferenceX revision.",
+  "schema_version": 1,
+  "framework": "inferencemax_single",
+  "gpu_arch": "mi355x",
+  "enforce_thresholds": false,
+  "paths": {
+    "shared_fs": "/home/{user-id}",
+    "models_dir": "{shared_fs}/models",
+    "log_dir": "{shared_fs}/LOGS",
+    "hf_token_file": "{shared_fs}/.hf_token"
+  },
+  "model": {
+    "id": "openai/gpt-oss-120b",
+    "remote": 0,
+    "precision": "bf16"
+  },
+  "container": {
+    "lifetime": "per_run",
+    "name": "<changeme>",
+    "image": "<changeme>",
+    "runtime": {
+      "name": "docker",
+      "args": {
+        "network": "host",
+        "ipc": "host",
+        "privileged": true,
+        "shm_size": "128G",
+        "volumes": [
+          "/home/{user-id}:/home/{user-id}"
+        ],
+        "devices": [
+          "/dev/dri",
+          "/dev/kfd"
+        ]
+      }
+    }
+  },
+  "roles": {
+    "server": {
+      "serve_args": {
+        "enforce-eager": true,
+        "gpu-memory-utilization": "0.92",
+        "block-size": 64,
+        "no-enable-prefix-caching": true
+      },
+      "env": {}
+    }
+  },
+  "params": {
+    "backend": "vllm",
+    "base_url": "http://0.0.0.0",
+    "port_no": "8000",
+    "dataset_name": "random",
+    "burstiness": "1.0",
+    "seed": "0",
+    "request_rate": "inf",
+    "random_range_ratio": "0.8",
+    "random_prefix_len": "0",
+    "tensor_parallelism": "8",
+    "tokenizer_mode": "auto",
+    "percentile_metrics": "ttft,tpot,itl,e2el",
+    "metric_percentiles": "99",
+    "num_prompts": "1000",
+    "max_model_length": "8192",
+    "client_poll_count": "50",
+    "client_poll_wait_time": "60",
+    "bench_max_failed_requests": "0"
+  },
+  "sweep": {
+    "sequence_combinations": [
+      {
+        "name": "legacy_profile",
+        "isl": "7168",
+        "osl": "1024"
+      }
+    ],
+    "runs": [
+      {
+        "combo": "legacy_profile",
+        "concurrency": 64
+      }
+    ]
+  }
+}
diff --git a/cvs/input/config_file/inference/inferencemax_single/mi355x_inferencemax_gpt_oss_120b_single/mi355x_inferencemax_gpt_oss_120b_single_threshold.json b/cvs/input/config_file/inference/inferencemax_single/mi355x_inferencemax_gpt_oss_120b_single/mi355x_inferencemax_gpt_oss_120b_single_threshold.json
new file mode 100644
index 00000000..fac248f2
--- /dev/null
+++ b/cvs/input/config_file/inference/inferencemax_single/mi355x_inferencemax_gpt_oss_120b_single/mi355x_inferencemax_gpt_oss_120b_single_threshold.json
@@ -0,0 +1,97 @@
+{
+  "_comment": "client.* thresholds for ISL=7168,OSL=1024,TP=8,CONC=64. Placeholder values until MI355x is calibrated; enforce_thresholds=false in config.json.",
+  "ISL=7168,OSL=1024,TP=8,CONC=64": {
+    "client.total_token_throughput": {
+      "kind": "min_tok_s",
+      "value": 0
+    },
+    "client.output_throughput": {
+      "kind": "min_tok_s",
+      "value": 4200
+    },
+    "client.mean_ttft_ms": {
+      "kind": "max_ms",
+      "value": 500
+    },
+    "client.median_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_tpot_ms": {
+      "kind": "max_ms",
+      "value": 15
+    },
+    "client.median_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.median_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.median_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.success_rate": {
+      "kind": "min",
+      "value": 0
+    },
+    "client.failed": {
+      "kind": "max",
+      "value": 1000000000
+    }
+  }
+}
diff --git a/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/w1_llama31_70b_fp8kv_config.json b/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/llama31_70b_fp8_config.json
similarity index 72%
rename from cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/w1_llama31_70b_fp8kv_config.json
rename to cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/llama31_70b_fp8_config.json
index 1fa4790e..3ceeac2e 100644
--- a/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/w1_llama31_70b_fp8kv_config.json
+++ b/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/llama31_70b_fp8_config.json
@@ -5,24 +5,19 @@
   "enforce_thresholds": false,
   "paths": {
     "shared_fs": "/home/{user-id}",
-    "models_dir": "/it-share/models",
+    "models_dir": "{shared_fs}/models",
     "log_dir": "{shared_fs}/LOGS",
-    "benchmark_scripts_dir": "{shared_fs}/benchmark_server_scripts",
-    "hf_token_file": "{shared_fs}/.hf_token"
+    "hf_token_file": "<changeme>"
   },
   "model": {
     "id": "amd/Llama-3.1-70B-Instruct-FP8-KV",
     "remote": 0,
     "precision": "fp8"
   },
-  "image": {
-    "tag": "rocm/vllm-dev:nightly-sshd",
-    "remote": 1
-  },
   "container": {
     "lifetime": "per_run",
     "name": "w1_llama31_70b_fp8kv_perf_inference_rocm",
-    "image": "rocm/vllm-dev:nightly-sshd",
+    "image": "<changeme>",
     "runtime": {
       "name": "docker",
       "args": {
@@ -38,7 +33,9 @@
   },
   "roles": {
     "server": {
-      "server_script": "llama31-70b-fp8kv_mi300x_vllm.sh"
+      "serve_args": {
+        "kv-cache-dtype": "fp8"
+      }
     }
   },
   "params": {
@@ -49,28 +46,33 @@
     "burstiness": "1.0",
     "seed": "0",
     "request_rate": "inf",
-    "max_model_length": "2304",
     "random_range_ratio": "0.8",
     "random_prefix_len": "0",
     "tensor_parallelism": "8",
     "tokenizer_mode": "auto",
     "percentile_metrics": "ttft,tpot,itl,e2el",
-    "metric_percentiles": "99",
+    "metric_percentiles": "50,90,95,99",
     "num_prompts": "3200",
     "client_poll_count": "90"
   },
   "sweep": {
     "sequence_combinations": [
       {
+        "name": "w1_isl=128_osl=2048",
         "isl": "128",
         "osl": "2048",
-        "name": "throughput"
+        "goodput_slo": {
+          "ttft_ms": 1000000000.0,
+          "tpot_ms": 1000000000.0,
+          "e2el_ms": 1000000000.0
+        }
       }
     ],
-    "concurrency_levels": [
-      64,
-      128,
-      256
+    "runs": [
+      {
+        "combo": "w1_isl=128_osl=2048",
+        "concurrency": 16
+      }
     ]
   }
 }
diff --git a/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/llama31_70b_fp8_threshold.json b/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/llama31_70b_fp8_threshold.json
new file mode 100644
index 00000000..c5b9fb46
--- /dev/null
+++ b/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/llama31_70b_fp8_threshold.json
@@ -0,0 +1,97 @@
+{
+  "_comment": "PLACEHOLDER thresholds for W1 (Llama 3.1 70B FP8-KV, in=128/out=2048, TP=8, conc=16) -- the single cell the sweep enumerates. Every gated metric (vllm_parsing.GATED_METRICS: throughput, the full latency distribution mean/median/p90/p95/p99 per ttft/tpot/itl/e2el family, and success_rate/failed health) has a spec here so the loader gated-coverage check passes. Values are NOT calibrated (AMD publishes throughput-vs-latency curves, not per-cell scalars). config.json sets enforce_thresholds=false: the suite records metrics and skips pass/fail. Replace placeholders with real numbers and flip enforce_thresholds=true to assert.",
+  "ISL=128,OSL=2048,TP=8,CONC=16": {
+    "client.total_token_throughput": {
+      "kind": "min_tok_s",
+      "value": 0
+    },
+    "client.output_throughput": {
+      "kind": "min_tok_s",
+      "value": 0
+    },
+    "client.mean_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.median_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_ttft_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.median_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_tpot_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.median_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_itl_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.mean_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.median_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p90_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p95_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.p99_e2el_ms": {
+      "kind": "max_ms",
+      "value": 1000000
+    },
+    "client.success_rate": {
+      "kind": "min",
+      "value": 0
+    },
+    "client.failed": {
+      "kind": "max",
+      "value": 1000000000
+    }
+  }
+}
diff --git a/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/w1_llama31_70b_fp8kv_threshold.json b/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/w1_llama31_70b_fp8kv_threshold.json
deleted file mode 100644
index 96d2674c..00000000
--- a/cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/w1_llama31_70b_fp8kv_threshold.json
+++ /dev/null
@@ -1,45 +0,0 @@
-{
-  "_comment": "PLACEHOLDER thresholds for W1 (Llama 3.1 70B FP8-KV, in=128/out=2048, TP=8). AMD's published source (performance-results.html) gives throughput-vs-latency curves, not tabulated per-cell numbers, so these are not yet calibrated. config.json sets enforce_thresholds=false: the suite records metrics and skips pass/fail. Replace min_tok_s/max_ms with real numbers and flip enforce_thresholds=true to make this cell assert.",
-  "ISL=128,OSL=2048,TP=8,CONC=64": {
-    "total_throughput_per_sec": {
-      "kind": "min_tok_s",
-      "value": 0
-    },
-    "mean_ttft_ms": {
-      "kind": "max_ms",
-      "value": 1000000
-    },
-    "mean_tpot_ms": {
-      "kind": "max_ms",
-      "value": 1000000
-    }
-  },
-  "ISL=128,OSL=2048,TP=8,CONC=128": {
-    "total_throughput_per_sec": {
-      "kind": "min_tok_s",
-      "value": 0
-    },
-    "mean_ttft_ms": {
-      "kind": "max_ms",
-      "value": 1000000
-    },
-    "mean_tpot_ms": {
-      "kind": "max_ms",
-      "value": 1000000
-    }
-  },
-  "ISL=128,OSL=2048,TP=8,CONC=256": {
-    "total_throughput_per_sec": {
-      "kind": "min_tok_s",
-      "value": 0
-    },
-    "mean_ttft_ms": {
-      "kind": "max_ms",
-      "value": 1000000
-    },
-    "mean_tpot_ms": {
-      "kind": "max_ms",
-      "value": 1000000
-    }
-  }
-}
diff --git a/cvs/lib/dtni/config_loader.py b/cvs/lib/dtni/config_loader.py
deleted file mode 100644
index d1010f2a..00000000
--- a/cvs/lib/dtni/config_loader.py
+++ /dev/null
@@ -1,301 +0,0 @@
-'''
-Copyright 2025 Advanced Micro Devices, Inc.
-All rights reserved.
-
-Typed config loader for the dtni vllm_single PoC.
-
-Loads a per-variant `config.json` + sibling `*_threshold.json`, validates
-shape with pydantic v2 (extra="forbid"), and runs a 3-pass placeholder
-substitution:
-  1. cluster placeholders (`{user-id}`) anywhere
-  2. self-reference within `paths` (e.g. `{shared_fs}`)
-  3. cross-block (`{paths.models_dir}`, etc.) into the rest of the doc
-
-A loaded variant is returned as a `VariantConfig` instance whose `container`
-field (`lifetime`, `name`, `image`, `runtime`) matches the dict shape that
-`cvs.core.orchestrators.factory.OrchestratorConfig` already understands.
-`runtime` is a nested `RuntimeSpec`, not a flat dict; `container.model_dump()`
-serialises it to the `runtime: {name, args}` shape the factory consumes (the
-vllm conftest does exactly this before building the orchestrator). The result
-also carries a `thresholds` field with the parsed threshold contents.
-
-`model.remote=1` raises NotImplementedError -- schema is present, but the
-download/resolve logic lives in cvs-dtni-v1's `resource_resolver.py` and
-is out of scope for this PoC.
-
-GENERALIZATION SEAM (do this on the SECOND consumer, not speculatively):
-`Paths`/`ModelSpec`/`ImageSpec`/`ContainerSpec`/`thresholds`, the placeholder
-substitution, the `enforce_thresholds` gate, and `load_variant` are
-framework-agnostic. `Params`, `Sweep`, `Roles`, and `cell_key`/`expected_cells`
-(the ISL/OSL/TP/CONC key shape) are vllm_single-specific. When the next
-framework lands (sglang-disagg, distributed, or a training suite), split this
-into a `BaseVariantConfig` (the generic half) + per-framework subclasses
-carrying their own `Params`/`Sweep`/`cell_key`. Extracting now -- with one
-consumer -- would be guessing the seam.
-'''
-
-from __future__ import annotations
-
-import getpass
-import json
-import re
-import warnings
-from pathlib import Path
-from typing import Any, Dict, List
-
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-from typing_extensions import Literal
-
-
-# ---------- pydantic models ----------
-
-
-class _Forbid(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-
-class _Allow(BaseModel):
-    model_config = ConfigDict(extra="allow")
-
-
-class Paths(_Forbid):
-    shared_fs: str
-    models_dir: str
-    log_dir: str
-    benchmark_scripts_dir: str
-    hf_token_file: str
-
-
-class ModelSpec(_Forbid):
-    id: str
-    remote: Literal[0, 1]
-    precision: str
-
-
-class ImageSpec(_Forbid):
-    tag: str
-    remote: Literal[0, 1]
-
-
-class RuntimeSpec(_Allow):
-    name: str
-    args: Dict[str, Any] = Field(default_factory=dict)
-
-
-class ContainerSpec(_Forbid):
-    lifetime: Literal["no_launch", "per_run", "persistent"] = "per_run"
-    name: str
-    image: str
-    runtime: RuntimeSpec
-
-
-class RoleServer(_Forbid):
-    server_script: str
-
-
-class Roles(_Forbid):
-    server: RoleServer
-
-
-class SeqCombo(_Forbid):
-    isl: str
-    osl: str
-    name: str
-
-
-class Sweep(_Forbid):
-    sequence_combinations: List[SeqCombo]
-    concurrency_levels: List[int]
-
-
-class Params(_Forbid):
-    backend: str = "vllm"
-    base_url: str = "http://0.0.0.0"
-    port_no: str = "8888"
-    dataset_name: str = "random"
-    burstiness: str = "1.0"
-    seed: str = "0"
-    request_rate: str = "inf"
-    max_model_length: str = "9216"
-    random_range_ratio: str = "0.8"
-    random_prefix_len: str = "0"
-    tensor_parallelism: str = "1"
-    tokenizer_mode: str = "auto"
-    percentile_metrics: str = "ttft,tpot,itl,e2el"
-    metric_percentiles: str = "99"
-    num_prompts: str = "3200"
-    # Completion-poll budget for the bench client = client_poll_count * 60s
-    # (plus a 120s initial wait). Large-output cells (high osl) need a bigger
-    # budget; the poll loop exits as soon as the client finishes, so raising
-    # this never slows down fast cells. See regressions REG-20260609-001.
-    client_poll_count: str = "20"
-
-
-class VariantConfig(_Forbid):
-    schema_version: Literal[1]
-    framework: Literal["vllm_single"]
-    gpu_arch: str
-    # When false, the threshold-coverage gate warns instead of raising and the
-    # test records metrics without asserting pass/fail (record-only). Use for
-    # un-calibrated shapes (e.g. a throughput characterization whose published
-    # numbers are curves, not tabulated values). Default true keeps the gate
-    # strict for calibrated configs -- no regression to the remediation work.
-    enforce_thresholds: bool = True
-    paths: Paths
-    model: ModelSpec
-    image: ImageSpec
-    container: ContainerSpec
-    roles: Roles
-    params: Params
-    sweep: Sweep
-    thresholds: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
-
-    # pydantic runs @model_validator(mode="after") hooks in definition order.
-    # This remote check is intentionally first: an unimplemented remote config
-    # fails fast (NotImplementedError) before _check_thresholds_cover_sweep runs,
-    # which is meaningless for a config we are going to reject anyway.
-    @model_validator(mode="after")
-    def _check_remote_not_implemented(self):
-        if self.model.remote == 1:
-            raise NotImplementedError(
-                "model.remote=1 (remote model download) is not implemented in the PoC. "
-                "Port from cvs-dtni-v1/resource_resolver.py before enabling."
-            )
-        return self
-
-    def cell_key(self, isl, osl, concurrency):
-        """The canonical threshold key for one sweep cell.
-
-        Single source of truth shared by the loader's coverage check and the
-        test's verdict lookup -- so the two can never drift on whitespace,
-        ordering, or field names.
-        """
-        return f"ISL={isl},OSL={osl},TP={self.params.tensor_parallelism},CONC={concurrency}"
-
-    def expected_cells(self):
-        """Every (isl, osl, conc) cell the sweep will parametrize."""
-        return [
-            self.cell_key(combo.isl, combo.osl, conc)
-            for combo in self.sweep.sequence_combinations
-            for conc in self.sweep.concurrency_levels
-        ]
-
-    @model_validator(mode="after")
-    def _check_thresholds_cover_sweep(self):
-        """Fail at load time if any sweep cell lacks a threshold entry.
-
-        Without this, a mistyped/whitespaced threshold key (or a new sweep
-        entry without a matching threshold) makes the test silently skip its
-        verdict and report a green PASS with zero assertions.
-
-        When `enforce_thresholds` is false the same mismatch is reported as a
-        warning rather than an error -- the config loads as a record-only
-        scaffold (metrics captured, no assertions) instead of failing.
-        """
-        expected = set(self.expected_cells())
-        present = set(self.thresholds.keys())
-        missing = sorted(expected - present)
-        extra = sorted(present - expected)
-        problems = []
-        if missing:
-            problems.append(f"sweep cells with no threshold entry: {missing}")
-        if extra:
-            problems.append(f"threshold keys matching no sweep cell (typo?): {extra}")
-        if problems:
-            msg = "threshold.json does not match the sweep matrix; " + "; ".join(problems)
-            if self.enforce_thresholds:
-                raise ValueError(msg)
-            warnings.warn(f"{msg} (enforce_thresholds=false -> record-only)", stacklevel=2)
-        return self
-
-
-# ---------- placeholder substitution ----------
-
-_PLACEHOLDER_RE = re.compile(r"\{([a-zA-Z0-9_.\-]+)\}")
-
-
-def _walk_substitute(node, mapping):
-    if isinstance(node, str):
-
-        def repl(m):
-            key = m.group(1)
-            if key in mapping:
-                return str(mapping[key])
-            return m.group(0)
-
-        return _PLACEHOLDER_RE.sub(repl, node)
-    if isinstance(node, list):
-        return [_walk_substitute(x, mapping) for x in node]
-    if isinstance(node, dict):
-        return {k: _walk_substitute(v, mapping) for k, v in node.items()}
-    return node
-
-
-def _flatten_paths(d, prefix=""):
-    out = {}
-    for k, v in d.items():
-        key = f"{prefix}.{k}" if prefix else k
-        if isinstance(v, dict):
-            out.update(_flatten_paths(v, key))
-        elif isinstance(v, (str, int, float)):
-            out[key] = str(v)
-    return out
-
-
-def _resolve_cluster_mapping(cluster_dict):
-    raw = cluster_dict.get("username") or "{user-id}"
-    user = getpass.getuser() if raw == "{user-id}" else raw
-    return {"user-id": user}
-
-
-# ---------- public API ----------
-
-
-def load_variant(config_path, cluster_dict):
-    """Load and validate a single variant config + its sibling threshold file.
-
-    The threshold file is the sole `*threshold.json` next to the config (e.g.
-    `w1_..._threshold.json` beside `w1_..._config.json`), so config and
-    threshold can share a descriptive per-variant prefix.
-    """
-    config_path = Path(config_path)
-    if not config_path.is_file():
-        raise FileNotFoundError(f"variant config not found: {config_path}")
-
-    raw = json.loads(config_path.read_text())
-
-    threshold_candidates = sorted(config_path.parent.glob("*threshold.json"))
-    if not threshold_candidates:
-        raise FileNotFoundError(f"no *threshold.json next to config: {config_path.parent}")
-    if len(threshold_candidates) > 1:
-        raise ValueError(f"multiple *threshold.json files next to config (ambiguous): {threshold_candidates}")
-    threshold_path = threshold_candidates[0]
-    thresholds = json.loads(threshold_path.read_text())
-
-    # Pass 1: cluster placeholders ({user-id}) everywhere.
-    cluster_map = _resolve_cluster_mapping(cluster_dict)
-    raw = _walk_substitute(raw, cluster_map)
-
-    # Pass 2: self-reference within paths ({shared_fs} inside paths.*).
-    paths_block = raw.get("paths", {})
-    if isinstance(paths_block, dict):
-        for _ in range(len(paths_block) + 1):
-            new = {
-                k: _walk_substitute(v, {pk: pv for pk, pv in paths_block.items() if isinstance(pv, str)})
-                for k, v in paths_block.items()
-            }
-            if new == paths_block:
-                break
-            paths_block = new
-        raw["paths"] = paths_block
-
-    # Pass 3: cross-block ({paths.models_dir} -> anywhere else).
-    flat_map = _flatten_paths({"paths": raw.get("paths", {})})
-    raw = _walk_substitute(raw, flat_map)
-
-    # Drop threshold-file comment keys (e.g. "_comment") before coverage check.
-    thresholds = {k: v for k, v in thresholds.items() if not k.startswith("_")}
-
-    # Validate sibling thresholds, attach, build VariantConfig.
-    raw["thresholds"] = thresholds
-    return VariantConfig(**raw)
diff --git a/cvs/lib/dtni/vllm_benchmark_scripts/README.md b/cvs/lib/dtni/vllm_benchmark_scripts/README.md
new file mode 100644
index 00000000..f73fa132
--- /dev/null
+++ b/cvs/lib/dtni/vllm_benchmark_scripts/README.md
@@ -0,0 +1,17 @@
+# vLLM benchmark server scripts (shared)
+
+Shell entrypoints for **`vllm serve`** kept for legacy **InferenceBaseJob** flows.
+
+- **`vllm_serve_mi300x.sh`** — reference MI300-class server flags (``enforce-eager``, ``gpu-memory-utilization``, etc.). **InferenceMax** and **vllm_single** encode equivalent flags in ``roles.server.serve_args`` instead of running this script.
+
+**Client benchmarks** use ``vllm bench serve`` (stock results artifact). CVS no longer clones a third-party ``bench_serving`` git repo for InferenceMax.
+
+If **both** the script path and the bench CLI are unavailable, install bench-capable vLLM in the image (e.g. `pip install 'vllm[bench]'`) or bind-mount a matching `benchmarks/` tree from a vLLM checkout.
+
+Client invocations also pass ``--temperature 0`` so greedy sampling matches the legacy
+``benchmark_serving.py`` default, and clamp ``--random-range-ratio`` when the configured
+spread would let ``(ISL+OSL)*(1+r)`` exceed ``max_model_length`` (otherwise vLLM rejects
+most random prompts).
+
+Python API: ``bundled_scripts_dir()``, ``bash_export_bench_script_from_vllm_install()``,
+``clamped_bench_random_range_ratio_str()``, ``validated_bench_script_basename()``.
diff --git a/cvs/lib/dtni/vllm_benchmark_scripts/__init__.py b/cvs/lib/dtni/vllm_benchmark_scripts/__init__.py
new file mode 100644
index 00000000..fefcafcb
--- /dev/null
+++ b/cvs/lib/dtni/vllm_benchmark_scripts/__init__.py
@@ -0,0 +1,200 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Canonical **vLLM benchmark server** shell helpers retained for legacy
+:class:`~cvs.lib.inference.base.InferenceBaseJob` flows. **InferenceMax** and
+**vllm_single** (:class:`~cvs.lib.inference.vllm_orch.VllmJob`) build
+``vllm serve`` in Python via ``roles.server.serve_args``; they do not stage
+these scripts at runtime.
+
+Client load generation uses the **vLLM install’s** ``benchmarks/<script>`` when present, otherwise
+``python -m vllm.entrypoints.cli.main bench serve`` (no third-party git clone).
+'''
+
+from __future__ import annotations
+
+import re
+import shlex
+import textwrap
+from pathlib import Path
+
+
+def bundled_scripts_dir() -> Path:
+    """Directory containing checked-in ``*.sh`` server entrypoints (package-relative)."""
+    return Path(__file__).resolve().parent
+
+
+def validated_bench_script_basename(name: str) -> str:
+    """Return a safe ``*.py`` basename under ``vllm/benchmarks/`` for ``bench_serv_script``."""
+    base = (name or "").strip().replace("\\", "/").rsplit("/", 1)[-1]
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*\.py", base):
+        raise ValueError(f"bench_serv_script must be a safe .py basename, got {name!r}")
+    return base
+
+
+def clamped_bench_random_range_ratio_str(
+    random_range_ratio: str | float | int,
+    input_sequence_length: str | float | int,
+    output_sequence_length: str | float | int,
+    max_model_length: str | float | int,
+) -> tuple[str, bool]:
+    """
+    Return ``(ratio_str, was_clamped)`` for ``--random-range-ratio`` on vLLM ``random`` datasets.
+
+    Current vLLM bench drivers sample input and output lengths near the configured ISL/OSL with
+    spread controlled by ``random_range_ratio`` (approximately ``ISL*(1±r)`` and ``OSL*(1±r)``).
+    If the peak combined length ``(ISL+OSL)*(1+r)`` would exceed ``max_model_length``, many
+    completion requests are rejected by the server; clamp ``r`` to ``max(0, MML/(ISL+OSL)-1)``.
+    """
+    raw_s = str(random_range_ratio).strip()
+    try:
+        r = float(raw_s)
+        isl = int(float(str(input_sequence_length).strip()))
+        osl = int(float(str(output_sequence_length).strip()))
+        mml = int(float(str(max_model_length).strip()))
+    except (TypeError, ValueError, ArithmeticError):
+        return raw_s, False
+
+    base = isl + osl
+    if base <= 0 or mml <= 0:
+        return raw_s, False
+
+    r_cap = mml / float(base) - 1.0
+    if r_cap < 0.0:
+        r_cap = 0.0
+    r_eff = min(max(r, 0.0), r_cap)
+    # Stable short decimal (avoid 0.30000000004-style floats in argv).
+    out = f"{r_eff:.12g}"
+    was = abs(r_eff - r) > 1e-12
+    return out, was
+
+
+def bash_export_bench_script_from_vllm_install(bench_serv_script: str) -> str:
+    """
+    Shell snippet that exports ``BENCH_PY``, ``BENCH_KIND``, ``BENCH_SCRIPT``, and defines
+    ``_cvs_run_bench`` — a shell function that invokes either the legacy script or
+    ``python -m vllm.entrypoints.cli.main bench serve``.
+
+    Tries ``python3.13``, ``python3.12``, …, ``python3`` so ROCm images where ``/usr/bin/python3``
+    is not the interpreter that owns the installed ``vllm`` package still resolve the driver.
+
+    Resolution searches several layouts (``site-packages/vllm/benchmarks/``, ancestors, bare
+    ``site-packages/benchmarks/``) because some vLLM wheels omit ``benchmarks/`` unless built
+    with bench extras; the probe opens the file before accepting a path.
+
+    If no ``benchmarks/<script>`` file exists but the install exposes the vLLM CLI bench entry
+    (``python -m vllm.entrypoints.cli.main bench serve``), ``BENCH_KIND`` is set to
+    ``cli_module`` and ``_cvs_run_bench`` forwards the same flags the legacy script accepted.
+
+    Fails at runtime if no interpreter can import ``vllm`` or neither a script nor the bench CLI
+    is usable.
+    """
+    base = validated_bench_script_basename(bench_serv_script)
+    py_body = textwrap.dedent(
+        f"""
+        import importlib.util, os, pathlib, shlex, site, subprocess, sys
+
+        import vllm
+
+        n = {base!r}
+
+        def esc(s):
+            return shlex.quote(str(s))
+
+        root = pathlib.Path(vllm.__file__).resolve().parent
+        seen = set()
+        cands = []
+
+        def add(p):
+            try:
+                q = pathlib.Path(p).resolve()
+            except Exception:
+                return
+            if q in seen:
+                return
+            seen.add(q)
+            cands.append(q)
+
+        add(root / "benchmarks" / n)
+        for anc in list(root.parents)[:8]:
+            add(anc / "benchmarks" / n)
+        for sp in site.getsitepackages():
+            sp = pathlib.Path(sp)
+            add(sp / "vllm" / "benchmarks" / n)
+            add(sp / "benchmarks" / n)
+        chosen = None
+        for c in cands:
+            if not (c.is_file() and os.access(c, os.R_OK)):
+                continue
+            try:
+                with c.open("rb") as f:
+                    f.read(1)
+            except OSError:
+                continue
+            chosen = c
+            break
+        if chosen:
+            print("export BENCH_PY=" + esc(sys.executable))
+            print("export BENCH_KIND=script")
+            print("export BENCH_SCRIPT=" + esc(str(chosen)))
+            sys.exit(0)
+
+        if importlib.util.find_spec("vllm.entrypoints.cli.main") is None:
+            sys.stderr.write(
+                "CVS: vLLM benchmark script %r not found after search and "
+                "``vllm.entrypoints.cli.main`` is missing. "
+                "Install a build that ships benchmarks (e.g. pip install 'vllm[bench]').\\n" % (n,)
+            )
+            sys.exit(1)
+        try:
+            r = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "vllm.entrypoints.cli.main",
+                    "bench",
+                    "serve",
+                    "--help",
+                ],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=120,
+                check=False,
+            )
+        except (OSError, subprocess.SubprocessError):
+            r = None
+        if r is None or r.returncode != 0:
+            sys.stderr.write(
+                "CVS: vLLM benchmark script %r not found and "
+                "``python -m vllm.entrypoints.cli.main bench serve`` is not available. "
+                "Many wheels omit ``vllm/benchmarks/``; install ``vllm[bench]`` or match your "
+                "Python interpreter to the vLLM install.\\n" % (n,)
+            )
+            sys.exit(1)
+        print("export BENCH_PY=" + esc(sys.executable))
+        print("export BENCH_KIND=cli_module")
+        print("export BENCH_SCRIPT=")
+        sys.exit(0)
+        """
+    ).strip()
+    py_q = shlex.quote(py_body)
+    # ``eval`` consumes ``export VAR=...`` lines from the probe (no ``read`` / process-substitution
+    # edge cases). ``_cvs_run_bench`` mirrors ``"$BENCH_PY" "$BENCH_SCRIPT"`` for script mode.
+    return (
+        "BENCH_PY=; BENCH_KIND=; BENCH_SCRIPT=; "
+        "for _cvs_py in python3.13 python3.12 python3.11 python3.10 python3; do "
+        f"_cvs_eval=$($_cvs_py -c {py_q} 2>/dev/null) || true; "
+        '[ -z "$_cvs_eval" ] && continue; '
+        'eval "$_cvs_eval" || continue; '
+        '[ -n "$BENCH_PY" ] && [ -n "$BENCH_KIND" ] && break; '
+        "done; "
+        '[ -n "$BENCH_KIND" ] && [ -n "$BENCH_PY" ] || '
+        "{ echo 'CVS: could not resolve vLLM benchmark driver (tried python3.13..python3)' >&2; exit 1; }; "
+        'if [ "$BENCH_KIND" = script ] && { [ ! -f "$BENCH_SCRIPT" ] || [ ! -r "$BENCH_SCRIPT" ]; }; then '
+        '{ echo "CVS: BENCH_SCRIPT is missing or unreadable: $BENCH_SCRIPT" >&2; exit 1; }; fi; '
+        '_cvs_run_bench() { case "$BENCH_KIND" in cli_module) '
+        '"$BENCH_PY" -m vllm.entrypoints.cli.main bench serve "$@" '
+        ';; *) "$BENCH_PY" "$BENCH_SCRIPT" "$@" ;; esac; }; '
+        "export BENCH_PY BENCH_KIND BENCH_SCRIPT"
+    )
diff --git a/cvs/lib/dtni/vllm_benchmark_scripts/vllm_serve_mi300x.sh b/cvs/lib/dtni/vllm_benchmark_scripts/vllm_serve_mi300x.sh
new file mode 100644
index 00000000..b8b91f49
--- /dev/null
+++ b/cvs/lib/dtni/vllm_benchmark_scripts/vllm_serve_mi300x.sh
@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# Model-agnostic vLLM server entrypoint for CVS benchmark flows on MI300-class GPUs.
+# Pass the checkpoint via MODEL (from server env); extra vLLM CLI flags via "$@".
+# Shared canonical copy: cvs.lib.dtni.vllm_benchmark_scripts (see README.md).
+# CVS runs: source /tmp/server_env_script.sh; nohup bash this_script ...
+# The load client is started separately by CVS (vLLM benchmarks/ driver).
+#
+# Default: --enforce-eager to reduce HIP "too many resources requested for launch"
+# failures during CUDA graph capture on some ROCm + vLLM + AITER stacks.
+# Disable with container env: VLLM_ENFORCE_EAGER=0
+
+set -euo pipefail
+
+: "${MODEL:?}" "${PORT:?}" "${TP:?}" "${MAX_MODEL_LEN:?}"
+
+# Bash: ${VAR:-1} does not apply default when VAR is set-but-empty (e.g. from env_dict).
+# Normalize whitespace-only to default, then drop the var so vLLM does not log
+# "Unknown vLLM environment variable: VLLM_ENFORCE_EAGER" (only the CLI flag is official).
+_raw_eager="${VLLM_ENFORCE_EAGER-}"
+[[ -z "${_raw_eager//[[:space:]]/}" ]] && _raw_eager=1
+ENFORCE_EAGER="${_raw_eager}"
+unset VLLM_ENFORCE_EAGER || true
+
+EAGER_FLAG=()
+case "${ENFORCE_EAGER}" in
+  1|true|TRUE|yes|YES) EAGER_FLAG=(--enforce-eager) ;;
+  *) ;;
+esac
+
+# GPU mem fraction for --gpu-memory-utilization only (not an official vLLM_* env; vLLM warns on unknown VLLM_*).
+# Prefer CVS_GPU_MEMORY_UTIL in container env_dict; accept legacy VLLM_GPU_MEMORY_UTIL then unset both.
+_raw_gpu="${CVS_GPU_MEMORY_UTIL:-${VLLM_GPU_MEMORY_UTIL:-}}"
+[[ -z "${_raw_gpu//[[:space:]]/}" ]] && _raw_gpu=0.92
+GPU_MEM="${_raw_gpu}"
+unset CVS_GPU_MEMORY_UTIL VLLM_GPU_MEMORY_UTIL || true
+
+echo "$(date -Is) [cvs vllm_serve_mi300x] vllm serve model=${MODEL} tp=${TP} max_model_len=${MAX_MODEL_LEN} port=${PORT} enforce_eager=${ENFORCE_EAGER} eager_flag_count=${#EAGER_FLAG[@]}"
+
+exec vllm serve "${MODEL}" \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --tensor-parallel-size "${TP}" \
+  --max-model-len "${MAX_MODEL_LEN}" \
+  --gpu-memory-utilization "${GPU_MEM}" \
+  --block-size 64 \
+  --no-enable-prefix-caching \
+  "${EAGER_FLAG[@]}" \
+  "$@"
diff --git a/cvs/lib/inference/base.py b/cvs/lib/inference/base.py
index d735f165..f150ee9c 100644
--- a/cvs/lib/inference/base.py
+++ b/cvs/lib/inference/base.py
@@ -7,9 +7,14 @@
 
 import os
 import re
+import shlex
 import time
 
 from cvs.lib import globals
+from cvs.lib.dtni.vllm_benchmark_scripts import (
+    bash_export_bench_script_from_vllm_install,
+    clamped_bench_random_range_ratio_str,
+)
 from cvs.lib.utils_lib import *
 from cvs.lib.verify_lib import *
 from cvs.lib import linux_utils
@@ -45,7 +50,9 @@ def __init__(
         hf_token,
         gpu_type='mi300',
         distributed_inference=False,
-        server_launch_poll_count=20,
+        # 60 * 60s polls after warmup matches VllmJob: large HF model cache + weight load
+        # on MI300 can exceed 20min with little log churn before Uvicorn prints ready.
+        server_launch_poll_count=60,
     ):
         # Client instance phdl
         self.c_phdl = c_phdl
@@ -75,6 +82,7 @@ def __init__(
         self.rdma_stats_dict_after = {}
         self.inference_start_time = s_phdl.exec('date +"%a %b %e %H:%M"')
         self.inference_end_time = None
+        self.inference_results_dict = {}
 
         self.home_dir = os.path.expanduser("~")
         self.if_dict.setdefault('container_image', 'rocm/7.0:rocm7.0_ubuntu_22.04_vllm_0.10.1_instinct_20250927_rc1')
@@ -90,7 +98,6 @@ def __init__(
         self.if_dict.setdefault('nccl_debug', 'ERROR')
         self.if_dict.setdefault('data_cache_dir', f'{self.home_dir}/cache')
         self.if_dict.setdefault('log_dir', f'{self.home_dir}/LOG_DIR')
-        self.if_dict.setdefault('benchmark_script_repo', 'https://github.com/kimbochen/bench_serving.git')
 
         log.info('%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%')
         log.info(f'inference_dict = {self.if_dict}')
@@ -138,8 +145,6 @@ def __init__(
             'failed to start|no such file or directory|command not found|cannot access', re.I
         )
         self.default_client_wait_time = 120
-        self.default_client_poll_count = 20
-        self.default_client_poll_wait_time = 60
 
         # Regex/parse defaults that derived classes may override
         self.readiness_pattern = re.compile('Application startup complete|Uvicorn running|Started server', re.I)
@@ -157,13 +162,32 @@ def __init__(
         self.bp_dict.setdefault('seed', '0')
         self.bp_dict.setdefault('request_rate', 'inf')
         self.bp_dict.setdefault('max_model_length', '9216')
-        self.bp_dict.setdefault('random_range_ration', '1.0')
+        self.bp_dict.setdefault('random_range_ratio', '1.0')
         self.bp_dict.setdefault('random_prefix_len', '0')
         self.bp_dict.setdefault('tensor_parallelism', '1')
         self.bp_dict.setdefault('port_no', '8000')
         self.bp_dict.setdefault('tokenizer_mode', 'auto')
         self.bp_dict.setdefault('percentile_metrics', 'ttft,tpot,itl,e2el')
         self.bp_dict.setdefault('metric_percentiles', '99')
+        # Bench client can exceed 20min for large num_prompts × long ISL/OSL; budget is
+        # default_client_wait_time + client_poll_count * client_poll_wait_time.
+        self.bp_dict.setdefault('client_poll_count', '50')
+        self.bp_dict.setdefault('client_poll_wait_time', '60')
+        self.bp_dict.setdefault('bench_max_failed_requests', '0')
+        try:
+            self.default_client_poll_count = max(1, int(float(str(self.bp_dict['client_poll_count']).strip())))
+        except (TypeError, ValueError):
+            self.default_client_poll_count = 50
+        try:
+            self.default_client_poll_wait_time = max(1, int(float(str(self.bp_dict['client_poll_wait_time']).strip())))
+        except (TypeError, ValueError):
+            self.default_client_poll_wait_time = 60
+        try:
+            self.bench_max_failed_requests_cap = max(
+                0, int(float(str(self.bp_dict['bench_max_failed_requests']).strip()))
+            )
+        except (TypeError, ValueError):
+            self.bench_max_failed_requests_cap = 0
 
         # Set server and client scripts
         self.server_script = self.bp_dict['server_script']
@@ -247,6 +271,11 @@ def exec_nic_setup_scripts(
     def build_server_inference_job_cmd(
         self,
     ):
+        eager_line = (
+            "\n                    export VLLM_ENFORCE_EAGER=1"
+            if self.if_dict.get("vllm_enforce_eager")
+            else ""
+        )
         s_cmd = f'''docker exec {self.container_name} /bin/bash -c "echo '
                     export MODEL={self.bp_dict['model']}
                     export ISL={self.bp_dict['input_sequence_length']}
@@ -258,7 +287,7 @@ def build_server_inference_job_cmd(
                     export HF_TOKEN={self.hf_token}
                     export VLLM_USE_AITER_UNIFIED_ATTENTION=1
                     export VLLM_ROCM_USE_AITER_MHA=0
-                    export VLLM_ROCM_USE_AITER_FUSED_MOE_A16W4=1
+                    export VLLM_ROCM_USE_AITER_FUSED_MOE_A16W4=1{eager_line}
                     export RESULT_FILENAME=results
                     export PORT={self.bp_dict['port_no']}'  > /tmp/server_env_script.sh"
                     '''
@@ -298,14 +327,10 @@ def build_server_inference_job_cmd(
         self.s_phdl.exec_cmd_list(cmd_list)
 
     def clone_bench_serving_repo(self, clone_dir):
-        """Clone bench_serving repository for client benchmarks."""
-        cmd = f'''docker exec {self.container_name} /bin/bash -c "cd {clone_dir}; git clone {self.if_dict['benchmark_script_repo']}" '''
-        out_dict = self.c_phdl.exec(cmd)
-        for node in out_dict.keys():
-            # Ignore "already exists" error - repo was cloned in previous test
-            if re.search('error|fail', out_dict[node], re.I) and not re.search('already exists', out_dict[node], re.I):
-                fail_test('Errors or failures seen in pulling bench_serving repo from Github, pls check')
-        time.sleep(3)
+        """No-op: client benchmarks use the installed ``vllm`` package ``benchmarks/<bench_serv_script>``."""
+        log.info(
+            "clone_bench_serving_repo skipped; using vLLM-shipped benchmarks/ (no third-party bench_serving clone)"
+        )
 
     def launch_server(self):
         """Launch inference server."""
@@ -352,10 +377,26 @@ def is_server_ready(self, out_dict, readiness_pattern):
         node_ready = {node: bool(readiness_pattern.search(output or '')) for node, output in out_dict.items()}
         return bool(node_ready) and all(node_ready.values())
 
+    def _readiness_grep_cmd_list(self, log_file: str) -> list[str]:
+        """Remote bash lines: print CVS_SERVER_READY if the full server log matches readiness.
+
+        Uses grep on the whole file (not tail) so the marker is not lost once vLLM logs scroll.
+        """
+        pat = self.readiness_pattern.pattern
+        cmd_list: list[str] = []
+        for i in range(0, int(self.nnodes)):
+            path = f'{self.log_dir}/{self.get_log_subdir()}/out-node{i}/{log_file}'.replace('\\', '/')
+            inner = f'grep -qiE {shlex.quote(pat)} {shlex.quote(path)} && echo CVS_SERVER_READY || true'
+            cmd_list.append(f'bash -c {shlex.quote(inner)}')
+        return cmd_list
+
+    @staticmethod
+    def _grep_readiness_outputs_ok(out_dict: dict) -> bool:
+        return bool(out_dict) and all('CVS_SERVER_READY' in (output or '') for output in out_dict.values())
+
     def poll_server_startup(self):
         """Poll for server startup completion."""
         log_file = f'{self.server_script}_server.log'
-        readiness_pattern = self.readiness_pattern
 
         # Do an early check for fast failures before the long wait
         log.info(f'Waiting {self.default_server_precheck_wait_time} secs for server to start writing logs...')
@@ -381,11 +422,10 @@ def poll_server_startup(self):
 
         for j in range(0, self.default_server_poll_count):
             log.info(f'Polling for application startup complete on all nodes, iteration {j}')
-            cmd_list = []
+            tail_cmds = []
             for i in range(0, int(self.nnodes)):
-                cmd = f'tail -30 {self.log_dir}/{self.get_log_subdir()}/out-node{i}/{log_file}'
-                cmd_list.append(cmd)
-            out_dict = self.s_phdl.exec_cmd_list(cmd_list)
+                tail_cmds.append(f'tail -30 {self.log_dir}/{self.get_log_subdir()}/out-node{i}/{log_file}')
+            out_dict = self.s_phdl.exec_cmd_list(tail_cmds)
 
             for node in out_dict.keys():
                 if self.default_server_error_pattern_poll.search(out_dict[node] or ''):
@@ -393,7 +433,8 @@ def poll_server_startup(self):
                     fail_test(error_msg)
                     raise Exception(error_msg)
 
-            if self.is_server_ready(out_dict, readiness_pattern):
+            grep_out = self.s_phdl.exec_cmd_list(self._readiness_grep_cmd_list(log_file))
+            if self._grep_readiness_outputs_ok(grep_out):
                 log.info('Server startup confirmed on all nodes')
                 return
 
@@ -410,11 +451,30 @@ def launch_client(self):
         backend = self.bp_dict['backend']
         result_filename = self.get_result_filename()
 
+        export_bench = bash_export_bench_script_from_vllm_install(self.bench_serv_script)
+
+        rr_str, rr_clamped = clamped_bench_random_range_ratio_str(
+            self.bp_dict["random_range_ratio"],
+            self.bp_dict["input_sequence_length"],
+            self.bp_dict["output_sequence_length"],
+            self.bp_dict["max_model_length"],
+        )
+        if rr_clamped:
+            log.info(
+                "CVS: clamped --random-range-ratio from %s to %s so peak random (ISL+OSL)*(1+r) "
+                "fits max_model_length=%s (ISL=%s OSL=%s)",
+                self.bp_dict["random_range_ratio"],
+                rr_str,
+                self.bp_dict["max_model_length"],
+                self.bp_dict["input_sequence_length"],
+                self.bp_dict["output_sequence_length"],
+            )
+
         # Launch client benchmark
         cmd_list = []
         for i in range(0, int(self.nnodes)):
-            client_cmd = f'''source /tmp/server_env_script.sh; cd {clone_dir}; \
-                    python3 bench_serving/{self.bench_serv_script} \
+            client_cmd = f'''source /tmp/server_env_script.sh; {export_bench}; cd {clone_dir}; \
+                    _cvs_run_bench \
                     --model {self.bp_dict['model']} \
                     --backend {backend} \
                     --base-url {self.bp_dict['base_url']}:{self.bp_dict['port_no']} \
@@ -427,15 +487,17 @@ def launch_client(self):
                     --burstiness {self.bp_dict['burstiness']} \
                     --tokenizer-mode {self.bp_dict['tokenizer_mode']} \
                     --seed {self.bp_dict['seed']} \
-                    --random-range-ratio {self.bp_dict['random_range_ratio']} \
+                    --random-range-ratio {rr_str} \
                     --random-prefix-len {self.bp_dict['random_prefix_len']} \
                     --percentile-metrics {self.bp_dict['percentile_metrics']} \
+                    --metric-percentiles {self.bp_dict['metric_percentiles']} \
+                    --temperature 0 \
                     --ignore-eos \
                     --save-result \
                     --result-dir {self.log_dir}/{self.get_log_subdir()}/out-node{i} \
                     --result-filename {result_filename} \
                     > {self.log_dir}/{self.get_log_subdir()}/out-node{i}/bench_serv_script.log 2>&1 &'''
-            cmd = f'''docker exec {self.container_name} /bin/bash -c "{client_cmd}" '''
+            cmd = f"docker exec {shlex.quote(str(self.container_name))} /bin/bash -c {shlex.quote(client_cmd)}"
             cmd_list.append(cmd)
         self.c_phdl.exec_cmd_list(cmd_list)
 
@@ -450,13 +512,35 @@ def poll_client_completion(self):
                 cmd = f'tail -30 {self.log_dir}/{self.get_log_subdir()}/out-node{i}/bench_serv_script.log'
                 cmd_list.append(cmd)
             out_dict = self.c_phdl.exec_cmd_list(cmd_list)
+            done = []
             for node in out_dict.keys():
-                if re.search('Failed', out_dict[node], re.I):
+                log_tail = out_dict[node] or ''
+                if re.search(r"can't open file|No such file or directory", log_tail, re.I):
+                    fail_test(
+                        f'Benchmark script missing or unreadable on node {node} '
+                        f'(see bench_serv_script.log); install vllm[bench] or use an image with benchmarks/.'
+                    )
+                    return
+                if re.search('Failed', log_tail, re.I):
                     fail_test(f'Failed to run benchmark script on node {node}')
                     return
-                if not re.search('End-to-end Latency', out_dict[node], re.I):
-                    log.info(f'Waiting {self.default_client_poll_wait_time} secs for next poll')
-                    time.sleep(self.default_client_poll_wait_time)
+                done.append(
+                    bool(
+                        re.search(
+                            r'Serving Benchmark Result|End-to-end Latency',
+                            log_tail,
+                            re.I,
+                        )
+                    )
+                )
+            if done and all(done):
+                log.info('Benchmark client complete on all nodes (iter=%d)', j)
+                return
+            log.info(f'Waiting {self.default_client_poll_wait_time} secs for next poll')
+            time.sleep(self.default_client_poll_wait_time)
+        msg = 'client did not complete before poll cap'
+        fail_test(msg)
+        raise Exception(msg)
 
     def start_inference_server_job(
         self,
@@ -471,7 +555,7 @@ def start_inference_client_job(
     ):
         log.info('Start Client side benchmark script on all Nodes')
 
-        # Clone bench_serving repo to /app
+        # Resolve benchmark driver from the installed vllm package (see dtni.vllm_benchmark_scripts)
         self.clone_bench_serving_repo('/app')
 
         if self.distributed_inference:
@@ -498,7 +582,7 @@ def get_inference_results_dict(self, out_dict):
                 self.inference_results_dict[node]['total_input_tokens'] = match.group(1)
             if re.search('Total generated tokens:', out_dict[node], re.I):
                 match = re.search('Total generated tokens:\s+([0-9\.]+)', out_dict[node], re.I)
-                self.inference_results_dict[node]['Total generated tokens:'] = match.group(1)
+                self.inference_results_dict[node]['total_generated_tokens'] = match.group(1)
             if re.search('Request throughput \(req/s\):', out_dict[node], re.I):
                 match = re.search('Request throughput \(req/s\):\s+([0-9\.]+)', out_dict[node], re.I)
                 self.inference_results_dict[node]['request_throughput_per_sec'] = match.group(1)
@@ -511,20 +595,20 @@ def get_inference_results_dict(self, out_dict):
             if re.search('Mean TTFT \(ms\):', out_dict[node], re.I):
                 match = re.search('Mean TTFT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
                 self.inference_results_dict[node]['mean_ttft_ms'] = match.group(1)
-            if re.search('Median TTFT (ms):', out_dict[node], re.I):
-                match = re.search('Median TTFT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
+            if re.search(r'Median TTFT \(ms\):', out_dict[node], re.I):
+                match = re.search(r'Median TTFT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
                 self.inference_results_dict[node]['median_ttft_ms'] = match.group(1)
-            if re.search('P99 TTFT (ms):', out_dict[node], re.I):
-                match = re.search('P99 TTFT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
+            if re.search(r'P99 TTFT \(ms\):', out_dict[node], re.I):
+                match = re.search(r'P99 TTFT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
                 self.inference_results_dict[node]['p99_ttft_ms'] = match.group(1)
             if re.search('Mean TPOT \(ms\)', out_dict[node], re.I):
                 match = re.search('Mean TPOT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
                 self.inference_results_dict[node]['mean_tpot_ms'] = match.group(1)
             if re.search('Median TPOT \(ms\):', out_dict[node], re.I):
-                match = re.search('Median TPOT \(ms\):\s+([0-9]+)', out_dict[node], re.I)
+                match = re.search('Median TPOT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
                 self.inference_results_dict[node]['median_tpot_ms'] = match.group(1)
-            if re.search('P99 TPOT (ms):', out_dict[node], re.I):
-                match = re.search('P99 TPOT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
+            if re.search(r'P99 TPOT \(ms\):', out_dict[node], re.I):
+                match = re.search(r'P99 TPOT \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
                 self.inference_results_dict[node]['p99_tpot_ms'] = match.group(1)
             if re.search('Mean ITL \(ms\):', out_dict[node], re.I):
                 match = re.search('Mean ITL \(ms\):\s+([0-9\.]+)', out_dict[node], re.I)
diff --git a/cvs/lib/inference/inference_max.py b/cvs/lib/inference/inference_max.py
deleted file mode 100644
index 61f91844..00000000
--- a/cvs/lib/inference/inference_max.py
+++ /dev/null
@@ -1,56 +0,0 @@
-'''
-Copyright 2025 Advanced Micro Devices, Inc.
-All rights reserved. This notice is intended as a precaution against inadvertent publication and does not imply publication or any waiver of confidentiality.
-The year included in the foregoing notice is the year of creation of the work.
-All code contained here is Property of Advanced Micro Devices, Inc.
-'''
-
-import re
-import time
-
-from cvs.lib.inference.base import InferenceBaseJob
-from cvs.lib.verify_lib import fail_test
-
-
-class InferenceMaxJob(InferenceBaseJob):
-    """InferenceMAX-specific implementation."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.if_dict.setdefault('inferencemax_repo', 'https://github.com/InferenceMAX/InferenceMAX.git')
-
-    def get_server_script_directory(self):
-        """InferenceMAX scripts are in the cloned repo."""
-        return '/app/InferenceX'
-
-    def get_server_script_path(self):
-        """InferenceMAX scripts are in the cloned repo."""
-        base = "single_node" if int(self.nnodes) == 1 else "multi_node"
-        return f'benchmarks/{base}/{self.server_script}'
-
-    def get_result_filename(self):
-        """InferenceMAX result filename."""
-        return 'inferencemax_test_result.json'
-
-    def get_completion_pattern(self):
-        """InferenceMAX completion pattern."""
-        return re.compile('Serving Benchmark Result', re.I)
-
-    def get_log_subdir(self):
-        """InferenceMAX uses 'inference-max' log subdirectory."""
-        return 'inference-max'
-
-    def clone_inferencemax_repo(self):
-        """Clone InferenceMAX repository."""
-        cmd = f'''docker exec {self.container_name} /bin/bash -c "git clone {self.if_dict['inferencemax_repo']}" '''
-        out_dict = self.s_phdl.exec(cmd)
-        for node in out_dict.keys():
-            if re.search('error|fail', out_dict[node], re.I):
-                fail_test('Errors or failures seen in pulling InferenceMAX repo from Github, pls check')
-        time.sleep(3)
-        self.s_phdl.exec(f'''docker exec {self.container_name} /bin/bash -c "ls -ld /app/InferenceX" ''')
-
-    def start_inference_server_job(self):
-        """Start InferenceMAX server - clone repo, then call base implementation."""
-        self.clone_inferencemax_repo()
-        super().start_inference_server_job()
diff --git a/cvs/lib/inference/inferencemax_orch.py b/cvs/lib/inference/inferencemax_orch.py
new file mode 100644
index 00000000..ef720215
--- /dev/null
+++ b/cvs/lib/inference/inferencemax_orch.py
@@ -0,0 +1,309 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Standalone InferenceMax single-node job driven by a ContainerOrchestrator.
+
+Mirrors :class:`cvs.lib.inference.vllm_orch.VllmJob`: Python-built ``vllm serve``,
+``vllm bench serve``, and artifact parsing via ``to_client_metrics``. Does NOT
+subclass :class:`cvs.lib.inference.base.InferenceBaseJob`.
+'''
+
+from __future__ import annotations
+
+import json
+import re
+import shlex
+import time
+
+from cvs.lib import globals
+from cvs.lib.inference.utils.vllm_parsing import to_client_metrics
+
+log = globals.log
+
+
+class InferenceMaxJob:
+    """Single-node InferenceMax benchmark job driven by an injected ContainerOrchestrator."""
+
+    READINESS_RE = re.compile(r"Application startup complete|Uvicorn running|Started server", re.I)
+    COMPLETION_RE = re.compile(r"Serving Benchmark Result", re.I)
+    FAILED_REQUESTS_RE = re.compile(r"Failed requests:\s+([0-9]+)", re.I)
+    CLIENT_CRASH_RE = re.compile(r"Traceback \(most recent call last\)", re.I)
+    CLIENT_LAUNCH_FAIL_RE = re.compile(
+        r"unrecognized arguments|invalid choice|error: argument |command not found|: No such file or directory",
+        re.I,
+    )
+    EARLY_FAILURE_RE = re.compile(
+        r"no such file or directory|command not found|cannot access|failed to start",
+        re.I,
+    )
+
+    _DEFAULT_SERVE_ARGS = {
+        "block-size": 64,
+        "no-enable-prefix-caching": True,
+    }
+
+    def __init__(
+        self,
+        orch,
+        variant,
+        hf_token,
+        isl,
+        osl,
+        concurrency,
+        num_prompts,
+        log_subdir="inference-max",
+        server_precheck_wait_s=30,
+        server_warmup_wait_s=330,
+        server_poll_count=60,
+        server_poll_wait_s=60,
+        client_initial_wait_s=120,
+        client_poll_count=50,
+        client_poll_wait_s=60,
+        bench_max_failed_requests=0,
+    ):
+        self.orch = orch
+        self.variant = variant
+        self.hf_token = hf_token
+        self.isl = str(isl)
+        self.osl = str(osl)
+        self.concurrency = str(concurrency)
+        self.num_prompts = str(num_prompts)
+        self.log_subdir = log_subdir
+
+        p = variant.params
+        self.tp = p.tensor_parallelism
+        self.port_no = p.port_no
+        self.random_range_ratio = p.random_range_ratio
+        self.random_prefix_len = p.random_prefix_len
+        self.burstiness = p.burstiness
+        self.seed = p.seed
+        self.request_rate = p.request_rate
+        self.tokenizer_mode = p.tokenizer_mode
+        self.percentile_metrics = p.percentile_metrics
+        self.metric_percentiles = p.metric_percentiles
+        self.base_url = p.base_url
+        self.dataset_name = p.dataset_name
+        self.backend = p.backend
+        self.max_model_length = str(p.max_model_length)
+
+        self.model_id = variant.model.id
+        self.log_dir = variant.paths.log_dir
+        self.models_dir = variant.paths.models_dir
+        self.serve_args = self._merged_serve_args(variant)
+        self.server_env = dict(variant.roles.server.env)
+
+        self.out_dir = (
+            f"{self.log_dir}/{self.log_subdir}/out-node0/"
+            f"isl{self.isl}_osl{self.osl}_conc{self.concurrency}"
+        )
+        self.server_log = f"{self.out_dir}/vllm_serve_server.log"
+        self.client_log = f"{self.out_dir}/client.log"
+
+        self._precheck_wait = server_precheck_wait_s
+        self._warmup_wait = server_warmup_wait_s
+        self._server_poll_count = server_poll_count
+        self._server_poll_wait = server_poll_wait_s
+        self._client_initial_wait = client_initial_wait_s
+        self._client_poll_count = client_poll_count
+        self._client_poll_wait = client_poll_wait_s
+        self._bench_max_failed_requests = int(bench_max_failed_requests)
+
+    @classmethod
+    def _merged_serve_args(cls, variant):
+        merged = dict(cls._DEFAULT_SERVE_ARGS)
+        merged.update(variant.roles.server.serve_args)
+        env = variant.roles.server.env
+        gpu_mem = env.get("CVS_GPU_MEMORY_UTIL") or env.get("VLLM_GPU_MEMORY_UTIL")
+        if gpu_mem is not None and "gpu-memory-utilization" not in merged:
+            merged["gpu-memory-utilization"] = str(gpu_mem)
+        if "enforce-eager" not in merged:
+            merged["enforce-eager"] = True
+        return merged
+
+    @staticmethod
+    def _flatten_serve_args(mapping):
+        argv = []
+        for flag, value in mapping.items():
+            opt = f"--{flag}"
+            if value is True:
+                argv.append(opt)
+            elif isinstance(value, (list, tuple)):
+                for v in value:
+                    argv.extend([opt, str(v)])
+            else:
+                argv.extend([opt, str(value)])
+        return argv
+
+    def build_server_cmd(self):
+        env_lines = [
+            f"export HF_TOKEN={shlex.quote(self.hf_token)}",
+            f"export HF_HUB_CACHE={shlex.quote(self.models_dir)}",
+            "export VLLM_USE_AITER_UNIFIED_ATTENTION=1",
+            "export VLLM_ROCM_USE_AITER_MHA=0",
+            "export VLLM_ROCM_USE_AITER_FUSED_MOE_A16W4=1",
+        ]
+        for k, v in self.server_env.items():
+            if k in ("CVS_GPU_MEMORY_UTIL", "VLLM_GPU_MEMORY_UTIL", "VLLM_ENFORCE_EAGER"):
+                continue
+            env_lines.append(f"export {k}={shlex.quote(str(v))}")
+        env_script = "\n".join(env_lines) + "\n"
+        self.orch.exec("bash -c " + shlex.quote(f"printf '%s' {shlex.quote(env_script)} > /tmp/server_env_script.sh"))
+        self.orch.exec(f"mkdir -p {shlex.quote(self.out_dir)}")
+
+    def _server_argv(self):
+        argv = [
+            "vllm",
+            "serve",
+            self.model_id,
+            "--host",
+            "0.0.0.0",
+            "--tensor-parallel-size",
+            str(self.tp),
+            "--max-model-len",
+            self.max_model_length,
+            "--port",
+            str(self.port_no),
+        ]
+        argv.extend(self._flatten_serve_args(self.serve_args))
+        return argv
+
+    def start_server(self):
+        serve_cmd = " ".join(shlex.quote(str(a)) for a in self._server_argv())
+        inner = (
+            f"source /tmp/server_env_script.sh && "
+            f"nohup {serve_cmd} > {shlex.quote(self.server_log)} 2>&1 &"
+        )
+        out = self.orch.exec("bash -c " + shlex.quote(inner))
+        for host, output in out.items():
+            if self.EARLY_FAILURE_RE.search(output or ""):
+                raise RuntimeError(f"vllm server failed to launch on {host}: {output[-500:]}")
+
+    def is_ready(self):
+        pattern = self.READINESS_RE.pattern
+        out = self.orch.exec(
+            f"grep -qiE {shlex.quote(pattern)} {shlex.quote(self.server_log)}",
+            detailed=True,
+        )
+        return bool(out) and all(r["exit_code"] == 0 for r in out.values())
+
+    def wait_ready(self):
+        log.info("waiting %ds for server log to materialise", self._precheck_wait)
+        time.sleep(self._precheck_wait)
+
+        out = self.orch.exec(f"tail -30 {shlex.quote(self.server_log)}")
+        for host, output in out.items():
+            if self.EARLY_FAILURE_RE.search(output or ""):
+                raise RuntimeError(f"vllm server early failure on {host}: {output[-500:]}")
+
+        log.info("warmup wait %ds", self._warmup_wait)
+        time.sleep(self._warmup_wait)
+
+        for it in range(self._server_poll_count):
+            if self.is_ready():
+                log.info("server ready (iter=%d)", it)
+                return
+            time.sleep(self._server_poll_wait)
+        raise RuntimeError("vllm server did not become ready before timeout")
+
+    def stop_server(self):
+        log.info("stopping vllm server")
+        self.orch.exec("bash -c 'pkill -f \"vllm serve\" || true'")
+        time.sleep(5)
+
+    def run_client(self):
+        args = [
+            "vllm",
+            "bench",
+            "serve",
+            "--model",
+            self.model_id,
+            "--backend",
+            self.backend,
+            "--base-url",
+            f"{self.base_url}:{self.port_no}",
+            "--dataset-name",
+            self.dataset_name,
+            "--num-prompts",
+            self.num_prompts,
+            "--random-input-len",
+            self.isl,
+            "--random-output-len",
+            self.osl,
+            "--max-concurrency",
+            self.concurrency,
+            "--request-rate",
+            self.request_rate,
+            "--burstiness",
+            self.burstiness,
+            "--tokenizer-mode",
+            self.tokenizer_mode,
+            "--seed",
+            self.seed,
+            "--random-range-ratio",
+            self.random_range_ratio,
+            "--random-prefix-len",
+            self.random_prefix_len,
+            "--percentile-metrics",
+            self.percentile_metrics,
+            "--metric-percentiles",
+            self.metric_percentiles,
+            "--ignore-eos",
+            "--save-result",
+            "--result-dir",
+            self.out_dir,
+            "--result-filename",
+            "results",
+        ]
+        bench_cmd = " ".join(shlex.quote(str(a)) for a in args)
+        client_cmd = f"source /tmp/server_env_script.sh && {bench_cmd} > {shlex.quote(self.client_log)} 2>&1 &"
+        self.orch.exec("bash -c " + shlex.quote(client_cmd))
+
+    def wait_client_complete(self):
+        log.info("client initial wait %ds", self._client_initial_wait)
+        time.sleep(self._client_initial_wait)
+        cap = self._bench_max_failed_requests
+        for it in range(self._client_poll_count):
+            out = self.orch.exec(f"tail -2000 {shlex.quote(self.client_log)}")
+            failed = []
+            done = []
+            for host, output in out.items():
+                txt = output or ""
+                done.append(bool(self.COMPLETION_RE.search(txt)))
+                if self.CLIENT_CRASH_RE.search(txt) or self.CLIENT_LAUNCH_FAIL_RE.search(txt):
+                    failed.append((host, txt[-500:]))
+                else:
+                    fm = self.FAILED_REQUESTS_RE.search(txt)
+                    if fm:
+                        fc = int(fm.group(1))
+                        if fc > cap:
+                            failed.append((host, f"Failed requests: {fc} (cap {cap}) -- {txt[-500:]}"))
+                        elif fc > 0:
+                            log.warning(
+                                "client on %s completed with %d failed requests (allowed up to %d)",
+                                host,
+                                fc,
+                                cap,
+                            )
+            if failed:
+                raise RuntimeError("client failed: " + "; ".join(f"{h}: {m}" for h, m in failed))
+            if done and all(done):
+                log.info("client complete (iter=%d)", it)
+                return
+            time.sleep(self._client_poll_wait)
+        raise RuntimeError("client did not complete before poll cap")
+
+    def parse_results(self):
+        artifact = f"{self.out_dir}/results"
+        out = self.orch.exec(f"cat {shlex.quote(artifact)}")
+        results = {}
+        for host, text in out.items():
+            text = (text or "").strip()
+            if not text:
+                raise RuntimeError(f"empty/missing results artifact on {host}: {artifact}")
+            try:
+                raw = json.loads(text)
+            except (json.JSONDecodeError, ValueError) as e:
+                raise RuntimeError(f"unparseable results artifact on {host}: {artifact}: {e}") from e
+            results[host] = to_client_metrics(raw, tp=self.tp, isl=self.isl)
+        return results
diff --git a/cvs/lib/inference/unittests/__init__.py b/cvs/lib/inference/unittests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/cvs/lib/inference/unittests/fixtures/vllm_results_sample.json b/cvs/lib/inference/unittests/fixtures/vllm_results_sample.json
new file mode 100644
index 00000000..84230482
--- /dev/null
+++ b/cvs/lib/inference/unittests/fixtures/vllm_results_sample.json
@@ -0,0 +1 @@
+{"date": "20260616-195845", "endpoint_type": "vllm", "backend": "vllm", "label": null, "model_id": "amd/Llama-3.1-70B-Instruct-FP8-KV", "tokenizer_id": "amd/Llama-3.1-70B-Instruct-FP8-KV", "num_prompts": 12800, "request_rate": "inf", "burstiness": 1.0, "max_concurrency": 256, "duration": 2689.1403915379196, "completed": 12800, "failed": 0, "total_input_tokens": 1638400, "total_output_tokens": 26214400, "request_throughput": 4.7598853671896535, "request_goodput": null, "output_throughput": 9748.24523200441, "total_token_throughput": 10357.510559004686, "max_output_tokens_per_s": 10765.0, "max_concurrent_requests": 512, "rtfx": 0.0, "mean_ttft_ms": 668.48989902217, "median_ttft_ms": 639.2352399416268, "std_ttft_ms": 450.33186696146356, "p99_ttft_ms": 2471.584795164014, "mean_tpot_ms": 25.931252678514355, "median_tpot_ms": 25.9539894319472, "std_tpot_ms": 0.21713041382746362, "p99_tpot_ms": 26.324707068246756, "mean_itl_ms": 25.9318070919762, "median_itl_ms": 25.50674183294177, "std_itl_ms": 8.843604314389477, "p99_itl_ms": 32.19962654635305, "mean_e2el_ms": 53749.76413194105, "median_e2el_ms": 53752.437153831124, "std_e2el_ms": 298.81966449031785, "p99_e2el_ms": 55124.09303063527}
\ No newline at end of file
diff --git a/cvs/lib/inference/unittests/fixtures/vllm_results_widened.json b/cvs/lib/inference/unittests/fixtures/vllm_results_widened.json
new file mode 100644
index 00000000..3e32870f
--- /dev/null
+++ b/cvs/lib/inference/unittests/fixtures/vllm_results_widened.json
@@ -0,0 +1,52 @@
+{
+  "date": "20260617-163232",
+  "endpoint_type": "vllm",
+  "backend": "vllm",
+  "label": null,
+  "model_id": "amd/Llama-3.1-70B-Instruct-FP8-KV",
+  "tokenizer_id": "amd/Llama-3.1-70B-Instruct-FP8-KV",
+  "num_prompts": 3200,
+  "request_rate": "inf",
+  "burstiness": 1.0,
+  "max_concurrency": 64,
+  "duration": 564.1147056743503,
+  "completed": 1791,
+  "failed": 1409,
+  "total_input_tokens": 229974,
+  "total_output_tokens": 2312408,
+  "request_throughput": 3.174886210170704,
+  "request_goodput": 3.174886210170704,
+  "output_throughput": 4099.180497760143,
+  "total_token_throughput": 4506.852904961594,
+  "max_output_tokens_per_s": 4590.0,
+  "max_concurrent_requests": 76,
+  "rtfx": 0.0,
+  "mean_ttft_ms": 291.88843878398956,
+  "median_ttft_ms": 73.2587007805705,
+  "std_ttft_ms": 1137.8571870825917,
+  "p50_ttft_ms": 73.2587007805705,
+  "p90_ttft_ms": 85.64653992652893,
+  "p95_ttft_ms": 91.81479038670659,
+  "p99_ttft_ms": 6259.152442589402,
+  "mean_tpot_ms": 15.032167084785439,
+  "median_tpot_ms": 15.03020008988302,
+  "std_tpot_ms": 0.3247818510561047,
+  "p50_tpot_ms": 15.03020008988302,
+  "p90_tpot_ms": 15.209271169796184,
+  "p95_tpot_ms": 15.24944565870449,
+  "p99_tpot_ms": 15.943741001209947,
+  "mean_itl_ms": 15.019441688915942,
+  "median_itl_ms": 14.628257602453232,
+  "std_itl_ms": 6.1097319902977505,
+  "p50_itl_ms": 14.628257602453232,
+  "p90_itl_ms": 15.559395030140879,
+  "p95_itl_ms": 17.392832040786708,
+  "p99_itl_ms": 27.511265948414778,
+  "mean_e2el_ms": 19668.871285726116,
+  "median_e2el_ms": 19835.17629932612,
+  "std_e2el_ms": 7829.601121737766,
+  "p50_e2el_ms": 19835.17629932612,
+  "p90_e2el_ms": 30145.559770055115,
+  "p95_e2el_ms": 31765.095902141184,
+  "p99_e2el_ms": 34034.53387795014
+}
diff --git a/cvs/lib/inference/unittests/test_inferencemax_config_loader.py b/cvs/lib/inference/unittests/test_inferencemax_config_loader.py
new file mode 100644
index 00000000..cd335a90
--- /dev/null
+++ b/cvs/lib/inference/unittests/test_inferencemax_config_loader.py
@@ -0,0 +1,71 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Unit tests for cvs.lib.inference.utils.inferencemax_config_loader.
+'''
+
+import unittest
+from pathlib import Path
+
+from cvs.lib.inference.utils.inferencemax_config_loader import (
+    InferenceMaxVariantConfig,
+    load_variant,
+    orchestrator_container_from_variant,
+    placeholder_gated_threshold_cell,
+)
+from cvs.lib.inference.utils.inferencing_config_loader import Run, SeqCombo, Sweep
+
+
+def _cluster_dict():
+    return {"username": "testuser"}
+
+
+class TestInferenceMaxConfigLoader(unittest.TestCase):
+    def test_load_mi300x_sample_config(self):
+        root = Path(__file__).resolve().parents[3]
+        config = root / (
+            "input/config_file/inference/inferencemax_single/"
+            "mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_config.json"
+        )
+        variant = load_variant(config, _cluster_dict())
+        self.assertEqual(variant.framework, "inferencemax_single")
+        self.assertEqual(variant.expected_cells(), ["ISL=7168,OSL=1024,TP=8,CONC=64"])
+        self.assertIn("enforce-eager", variant.roles.server.serve_args)
+
+    def test_orchestrator_container_includes_server_env(self):
+        sweep = Sweep(
+            sequence_combinations=[SeqCombo(name="legacy_profile", isl="7168", osl="1024")],
+            runs=[Run(combo="legacy_profile", concurrency=64)],
+        )
+        thresholds = {
+            "ISL=7168,OSL=1024,TP=8,CONC=64": placeholder_gated_threshold_cell(),
+        }
+        variant = InferenceMaxVariantConfig(
+            schema_version=1,
+            framework="inferencemax_single",
+            gpu_arch="mi300x",
+            enforce_thresholds=False,
+            paths={
+                "shared_fs": "/home/x",
+                "models_dir": "/home/x/models",
+                "log_dir": "/home/x/LOGS",
+                "hf_token_file": "/home/x/.hf",
+            },
+            model={"id": "openai/gpt-oss-120b", "remote": 0, "precision": "bf16"},
+            container={
+                "name": "c",
+                "image": "img",
+                "runtime": {"name": "docker", "args": {"volumes": ["/home/x:/home/x"]}},
+            },
+            roles={"server": {"env": {"VLLM_ROCM_USE_AITER": "1"}}},
+            params={"tensor_parallelism": "8"},
+            sweep=sweep,
+            thresholds=thresholds,
+        )
+        block = orchestrator_container_from_variant(variant)
+        self.assertEqual(block["env"]["VLLM_ROCM_USE_AITER"], "1")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/cvs/lib/inference/unittests/test_inferencemax_orch_parse.py b/cvs/lib/inference/unittests/test_inferencemax_orch_parse.py
new file mode 100644
index 00000000..883fa099
--- /dev/null
+++ b/cvs/lib/inference/unittests/test_inferencemax_orch_parse.py
@@ -0,0 +1,73 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Unit tests for InferenceMaxJob.parse_results (stock ``results`` artifact -> client.*).
+No hardware: a fake orch returns committed fixture text.
+'''
+
+import json
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+
+from cvs.lib.inference.inferencemax_orch import InferenceMaxJob
+
+_HERE = Path(__file__).parent
+_FIXTURES = _HERE / "fixtures"
+_ISL = 7168
+_OSL = 1024
+_TP = 8
+
+
+class FakeOrch:
+    def __init__(self, exec_return=None):
+        self.exec_return = exec_return if exec_return is not None else {}
+
+    def exec(self, cmd, **kwargs):
+        return self.exec_return
+
+
+def _fake_variant():
+    params = SimpleNamespace(
+        tensor_parallelism=str(_TP),
+        port_no="8000",
+        random_range_ratio="0.8",
+        random_prefix_len="0",
+        burstiness="1.0",
+        seed="0",
+        request_rate="inf",
+        tokenizer_mode="auto",
+        percentile_metrics="ttft,tpot,itl,e2el",
+        metric_percentiles="99",
+        base_url="http://0.0.0.0",
+        dataset_name="random",
+        backend="vllm",
+        max_model_length="8192",
+    )
+    roles = SimpleNamespace(server=SimpleNamespace(serve_args={}, env={}))
+    paths = SimpleNamespace(log_dir="/LOGS", models_dir="/models")
+    model = SimpleNamespace(id="openai/gpt-oss-120b")
+    return SimpleNamespace(params=params, roles=roles, paths=paths, model=model)
+
+
+class TestInferenceMaxOrchParse(unittest.TestCase):
+    def test_parse_results_maps_client_metrics(self):
+        raw = json.loads((_FIXTURES / "vllm_results_sample.json").read_text())
+        job = InferenceMaxJob(
+            orch=FakeOrch(exec_return={"node0": json.dumps(raw)}),
+            variant=_fake_variant(),
+            hf_token="tok",
+            isl=_ISL,
+            osl=_OSL,
+            concurrency=64,
+            num_prompts=100,
+        )
+        out = job.parse_results()
+        metrics = out["node0"]
+        self.assertIn("client.output_throughput", metrics)
+        self.assertIn("client.mean_ttft_ms", metrics)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/cvs/lib/inference/unittests/test_inferencing_config_loader.py b/cvs/lib/inference/unittests/test_inferencing_config_loader.py
new file mode 100644
index 00000000..8e64770c
--- /dev/null
+++ b/cvs/lib/inference/unittests/test_inferencing_config_loader.py
@@ -0,0 +1,197 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Unit tests for the sweep selector in
+cvs.lib.inference.utils.inferencing_config_loader: named combos + an explicit
+`runs` array (replacing the old sequence_combinations x concurrency_levels
+cartesian). No hardware. Covers the Sweep validator (unique names, known
+run.combo) and VariantConfig.expected_cells (the runs->cell_key expansion).
+'''
+
+import unittest
+
+from pydantic import ValidationError
+
+from cvs.lib.inference.utils.inferencing_config_loader import (
+    Run,
+    SeqCombo,
+    Sweep,
+    VariantConfig,
+)
+from cvs.lib.inference.utils.vllm_parsing import GATED_METRICS
+
+
+def _combo(name, isl="128", osl="2048"):
+    return SeqCombo(name=name, isl=isl, osl=osl)
+
+
+def _full_gated_specs():
+    """A spec for every gated metric -- the minimum that satisfies coverage.
+
+    Values are inert (a 0 floor / huge ceiling) so the set passes without
+    asserting anything; these tests pin the coverage gate, not the numbers.
+    """
+    out = {}
+    for m in GATED_METRICS:
+        kind = "max_ms" if m.endswith("_ms") else "max" if m == "failed" else "min"
+        out[f"client.{m}"] = {"kind": kind, "value": 0 if kind == "min" else 1e12}
+    return out
+
+
+def _variant(sweep, tp="8"):
+    """A minimal VariantConfig carrying just enough to exercise expected_cells.
+
+    remote=0 (the remote guard would otherwise reject it) and
+    enforce_thresholds=False so the empty threshold dict does not trip the
+    coverage check -- this test pins the selector expansion, not the gate.
+    """
+    return VariantConfig(
+        schema_version=1,
+        framework="vllm_single",
+        gpu_arch="mi300x",
+        enforce_thresholds=False,
+        paths={
+            "shared_fs": "/home/x",
+            "models_dir": "/home/x/models",
+            "log_dir": "/home/x/LOGS",
+            "hf_token_file": "/home/x/.hf",
+        },
+        model={"id": "amd/Llama-3.1-70B-Instruct-FP8-KV", "remote": 0, "precision": "fp8"},
+        container={
+            "name": "c",
+            "image": "rocm/vllm-dev:nightly-sshd",
+            "runtime": {"name": "docker"},
+        },
+        params={"tensor_parallelism": tp},
+        sweep=sweep,
+    )
+
+
+class TestSweepValidator(unittest.TestCase):
+    def test_valid_runs_selector_constructs(self):
+        sw = Sweep(
+            sequence_combinations=[_combo("a"), _combo("b", osl="4096")],
+            runs=[Run(combo="a", concurrency=16), Run(combo="b", concurrency=32)],
+        )
+        self.assertEqual([r.combo for r in sw.runs], ["a", "b"])
+
+    def test_unknown_run_combo_raises(self):
+        with self.assertRaises(ValidationError) as ctx:
+            Sweep(
+                sequence_combinations=[_combo("a")],
+                runs=[Run(combo="typo", concurrency=16)],
+            )
+        self.assertIn("names no sequence_combination", str(ctx.exception))
+
+    def test_duplicate_combo_names_raise(self):
+        with self.assertRaises(ValidationError) as ctx:
+            Sweep(
+                sequence_combinations=[_combo("a"), _combo("a", osl="4096")],
+                runs=[Run(combo="a", concurrency=16)],
+            )
+        self.assertIn("duplicate sequence_combination names", str(ctx.exception))
+
+    def test_concurrency_levels_is_rejected(self):
+        # The old cartesian key must be gone (extra=forbid): a config still
+        # carrying concurrency_levels should fail loudly, not silently ignore it.
+        with self.assertRaises(ValidationError):
+            Sweep(
+                sequence_combinations=[_combo("a")],
+                runs=[Run(combo="a", concurrency=16)],
+                concurrency_levels=[16],
+            )
+
+
+class TestExpectedCells(unittest.TestCase):
+    def test_runs_expand_to_exactly_their_cells(self):
+        sw = Sweep(
+            sequence_combinations=[_combo("a", isl="128", osl="2048"), _combo("b", isl="256", osl="4096")],
+            runs=[
+                Run(combo="a", concurrency=16),
+                Run(combo="b", concurrency=32),
+                Run(combo="a", concurrency=64),
+            ],
+        )
+        vc = _variant(sw)
+        self.assertEqual(
+            vc.expected_cells(),
+            [
+                "ISL=128,OSL=2048,TP=8,CONC=16",
+                "ISL=256,OSL=4096,TP=8,CONC=32",
+                "ISL=128,OSL=2048,TP=8,CONC=64",
+            ],
+        )
+
+    def test_no_cartesian_blowup(self):
+        # Two combos + two runs must yield TWO cells, not 2x2=4 (the old bug).
+        sw = Sweep(
+            sequence_combinations=[_combo("a"), _combo("b", osl="4096")],
+            runs=[Run(combo="a", concurrency=16), Run(combo="b", concurrency=16)],
+        )
+        self.assertEqual(len(_variant(sw).expected_cells()), 2)
+
+
+class TestGatedMetricCoverage(unittest.TestCase):
+    """The gated-metric axis of _check_thresholds_cover_sweep."""
+
+    _CELL = "ISL=128,OSL=2048,TP=8,CONC=16"
+
+    def _variant_with(self, thresholds, enforce):
+        sw = Sweep(
+            sequence_combinations=[_combo("a")],
+            runs=[Run(combo="a", concurrency=16)],
+        )
+        vc = _variant(sw)  # remote guard ok; enforce/thresholds set below
+        # _variant builds enforce_thresholds=False with empty thresholds; rebuild
+        # via construction so the validator runs against the real values.
+        return VariantConfig(
+            schema_version=1,
+            framework="vllm_single",
+            gpu_arch="mi300x",
+            enforce_thresholds=enforce,
+            paths={
+                "shared_fs": "/home/x",
+                "models_dir": "/home/x/models",
+                "log_dir": "/home/x/LOGS",
+                "hf_token_file": "/home/x/.hf",
+            },
+            model={"id": "amd/Llama-3.1-70B-Instruct-FP8-KV", "remote": 0, "precision": "fp8"},
+            container={"name": "c", "image": "rocm/vllm-dev:nightly-sshd", "runtime": {"name": "docker"}},
+            params={"tensor_parallelism": "8"},
+            sweep=sw,
+            thresholds=thresholds,
+        )
+
+    def test_full_gated_set_constructs(self):
+        vc = self._variant_with({self._CELL: _full_gated_specs()}, enforce=True)
+        self.assertEqual(vc.enforce_thresholds, True)
+
+    def test_missing_gated_metric_raises_when_enforced(self):
+        specs = _full_gated_specs()
+        del specs["client.p99_ttft_ms"]  # drop one gated metric
+        with self.assertRaises(ValidationError) as ctx:
+            self._variant_with({self._CELL: specs}, enforce=True)
+        self.assertIn("missing gated-metric specs", str(ctx.exception))
+        self.assertIn("client.p99_ttft_ms", str(ctx.exception))
+
+    def test_missing_gated_metric_warns_when_record_only(self):
+        specs = _full_gated_specs()
+        del specs["client.failed"]
+        import warnings as _w
+        with _w.catch_warnings(record=True) as caught:
+            _w.simplefilter("always")
+            self._variant_with({self._CELL: specs}, enforce=False)
+        self.assertTrue(any("missing gated-metric specs" in str(x.message) for x in caught))
+
+    def test_extra_non_gated_spec_is_allowed(self):
+        # A spec for a non-gated metric (record-only display extra) must not
+        # trip coverage -- gating is a floor, not an allow-list.
+        specs = _full_gated_specs()
+        specs["client.num_prompts"] = {"kind": "min", "value": 0}
+        vc = self._variant_with({self._CELL: specs}, enforce=True)
+        self.assertIn("client.num_prompts", vc.thresholds[self._CELL])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/cvs/lib/inference/unittests/test_vllm_orch_parse.py b/cvs/lib/inference/unittests/test_vllm_orch_parse.py
new file mode 100644
index 00000000..cc2c2394
--- /dev/null
+++ b/cvs/lib/inference/unittests/test_vllm_orch_parse.py
@@ -0,0 +1,527 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Unit tests for VllmJob.parse_results (stock `results` artifact -> client.* +
+derived metrics) and run_client's --goodput / --metric-percentiles flag
+construction. No hardware: a fake orch returns committed fixture text.
+'''
+
+import json
+import re
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+
+from cvs.lib.utils.verdict import ThresholdViolation, evaluate_all
+from cvs.lib.inference.vllm_orch import VllmJob
+
+_HERE = Path(__file__).parent
+_FIXTURES = _HERE / "fixtures"
+_REPO = _HERE.parents[3]  # cvs/lib/inference/unittests -> repo root
+_SHARED = _REPO / "cvs/tests/inference/vllm/_shared.py"
+_THRESHOLD = (
+    _REPO / "cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/llama31_70b_fp8_threshold.json"
+)
+
+# isl/tp used to build the job; must match the fixture's run for the derived
+# math assertions to be meaningful (real artifact: isl=128, tp=8).
+_ISL = 128
+_TP = 8
+
+
+class FakeOrch:
+    """Minimal stand-in for ContainerOrchestrator: records commands, returns a canned dict."""
+
+    def __init__(self, exec_return=None):
+        self.exec_return = exec_return if exec_return is not None else {}
+        self.commands = []
+
+    def exec(self, cmd, **kwargs):
+        self.commands.append(cmd)
+        return self.exec_return
+
+
+def _fake_variant():
+    """A SimpleNamespace tree carrying exactly the attributes VllmJob.__init__ reads."""
+    params = SimpleNamespace(
+        tensor_parallelism=str(_TP),
+        port_no="8888",
+        random_range_ratio="0.8",
+        random_prefix_len="0",
+        burstiness="1.0",
+        seed="0",
+        request_rate="inf",
+        tokenizer_mode="auto",
+        percentile_metrics="ttft,tpot,itl,e2el",
+        metric_percentiles="50,90,95,99",
+        base_url="http://0.0.0.0",
+        dataset_name="random",
+        backend="vllm",
+    )
+    return SimpleNamespace(
+        params=params,
+        model=SimpleNamespace(id="amd/Llama-3.1-70B-Instruct-FP8-KV"),
+        roles=SimpleNamespace(server=SimpleNamespace(serve_args={}, env={})),
+        paths=SimpleNamespace(log_dir="/tmp/logs", models_dir="/tmp/models"),
+    )
+
+
+def _make_job(orch, goodput_slo=None):
+    return VllmJob(
+        orch=orch,
+        variant=_fake_variant(),
+        hf_token="tok",
+        isl=_ISL,
+        osl=2048,
+        concurrency=256,
+        num_prompts=12800,
+        goodput_slo=goodput_slo,
+    )
+
+
+def _load_fixture(name):
+    return (_FIXTURES / name).read_text()
+
+
+class TestParseResults(unittest.TestCase):
+    def setUp(self):
+        self.real = json.loads(_load_fixture("vllm_results_sample.json"))
+        self.widened = json.loads(_load_fixture("vllm_results_widened.json"))
+
+    def _parse(self, fixture_name):
+        orch = FakeOrch({"fakehost": _load_fixture(fixture_name)})
+        job = _make_job(orch)
+        return job.parse_results()["fakehost"]
+
+    def test_all_stock_scalars_namespaced_and_numeric(self):
+        m = self._parse("vllm_results_widened.json")
+        # Every stock scalar appears 1:1 under client.* with its value preserved.
+        for k, v in self.widened.items():
+            ck = f"client.{k}"
+            self.assertIn(ck, m, f"missing {ck}")
+            self.assertEqual(m[ck], v)
+        # Spot-check a few are numeric (not the old scrape's strings).
+        for ck in ("client.total_token_throughput", "client.mean_ttft_ms", "client.p99_itl_ms"):
+            self.assertIsInstance(m[ck], (int, float))
+
+    def test_derived_metrics_exact(self):
+        m = self._parse("vllm_results_widened.json")
+        w = self.widened
+        self.assertAlmostEqual(m["client.per_gpu_throughput"], w["total_token_throughput"] / _TP)
+        self.assertAlmostEqual(m["client.normalized_ttft_ms_per_tok"], w["mean_ttft_ms"] / _ISL)
+        self.assertAlmostEqual(m["client.decode_latency_ratio"], w["p99_itl_ms"] / w["p50_itl_ms"])
+        self.assertAlmostEqual(m["client.decode_throughput_p50"], 1000.0 / w["median_tpot_ms"])
+        self.assertAlmostEqual(m["client.success_rate"], w["completed"] / (w["completed"] + w["failed"]))
+
+    def test_goodput_passthrough_null_and_value(self):
+        # Real artifact: request_goodput is null (ran without --goodput).
+        m_null = self._parse("vllm_results_sample.json")
+        self.assertIsNone(m_null["client.goodput"])
+        # Widened fixture: non-null goodput passed straight through.
+        m_val = self._parse("vllm_results_widened.json")
+        self.assertEqual(m_val["client.goodput"], self.widened["request_goodput"])
+
+    def test_decode_latency_ratio_none_when_p50_absent(self):
+        # The real artifact has no p50_itl_ms (it ran at metric_percentiles=99),
+        # so the ratio must degrade to None, not raise.
+        m = self._parse("vllm_results_sample.json")
+        self.assertIsNone(m["client.decode_latency_ratio"])
+
+    def test_missing_artifact_raises(self):
+        orch = FakeOrch({"fakehost": ""})
+        job = _make_job(orch)
+        with self.assertRaises(RuntimeError):
+            job.parse_results()
+
+    def test_unparseable_artifact_raises(self):
+        orch = FakeOrch({"fakehost": "not json {{{"})
+        job = _make_job(orch)
+        with self.assertRaises(RuntimeError):
+            job.parse_results()
+
+
+class TestRunClientFlags(unittest.TestCase):
+    def _client_cmd(self, goodput_slo):
+        orch = FakeOrch()
+        job = _make_job(orch, goodput_slo=goodput_slo)
+        job.run_client()
+        # run_client issues exactly one exec: bash -c '<client_cmd>'.
+        self.assertEqual(len(orch.commands), 1)
+        return orch.commands[0]
+
+    def test_metric_percentiles_flag_present(self):
+        cmd = self._client_cmd(None)
+        self.assertIn("--metric-percentiles", cmd)
+        self.assertIn("50,90,95,99", cmd)
+
+    def test_goodput_flag_omitted_when_none(self):
+        cmd = self._client_cmd(None)
+        self.assertNotIn("--goodput", cmd)
+
+    def test_goodput_flag_built_from_slo_dict(self):
+        slo = {"ttft_ms": 500.0, "tpot_ms": 50.0, "e2el_ms": 60000.0}
+        cmd = self._client_cmd(slo)
+        self.assertIn("--goodput", cmd)
+        for tok in ("ttft:500.0", "tpot:50.0", "e2el:60000.0"):
+            self.assertIn(tok, cmd)
+
+
+class TestKeyConsistency(unittest.TestCase):
+    """Mechanical guard (verification #5): every key the table reads and every
+    threshold cell key must be a key parse_results actually emits. Catches a
+    silent `-` column or a silent threshold skip WITHOUT a hardware run."""
+
+    def _producer_keys(self):
+        orch = FakeOrch({"fakehost": _load_fixture("vllm_results_widened.json")})
+        return set(_make_job(orch).parse_results()["fakehost"].keys())
+
+    def test_table_keys_are_produced(self):
+        produced = self._producer_keys()
+        shared_src = _SHARED.read_text()
+        table_keys = set(re.findall(r'_cell\(m,\s*"(client\.[^"]+)"', shared_src))
+        self.assertTrue(table_keys, "no client.* table keys found in _shared.py")
+        missing = table_keys - produced
+        self.assertEqual(missing, set(), f"table reads keys parse_results never emits: {missing}")
+
+    def test_threshold_keys_are_produced(self):
+        produced = self._producer_keys()
+        thr = json.loads(_THRESHOLD.read_text())
+        threshold_metric_keys = set()
+        for cell, metrics in thr.items():
+            if cell.startswith("_"):
+                continue
+            threshold_metric_keys.update(metrics.keys())
+        self.assertTrue(threshold_metric_keys, "no threshold metric keys found")
+        missing = threshold_metric_keys - produced
+        self.assertEqual(missing, set(), f"threshold asserts keys parse_results never emits: {missing}")
+
+
+class TestVerdictNoneGuard(unittest.TestCase):
+    """Regression (review fix #1): parse_results now emits metrics that are
+    legitimately None (derived ratio with no p50, goodput with no SLO run).
+    If a threshold targets one, evaluate_all must raise a clean
+    ThresholdViolation -- NOT a float(None) TypeError."""
+
+    def test_none_actual_raises_threshold_violation_not_typeerror(self):
+        actuals = {"client.goodput": None}
+        thresholds = {"client.goodput": {"kind": "min", "value": 1.0}}
+        with self.assertRaises(ThresholdViolation) as ctx:
+            evaluate_all(actuals, thresholds)
+        self.assertIn("value is None", str(ctx.exception))
+
+    def test_none_actual_does_not_mask_other_real_violations(self):
+        actuals = {"client.goodput": None, "client.total_token_throughput": 5.0}
+        thresholds = {
+            "client.goodput": {"kind": "min", "value": 1.0},
+            "client.total_token_throughput": {"kind": "min", "value": 10.0},
+        }
+        with self.assertRaises(ThresholdViolation) as ctx:
+            evaluate_all(actuals, thresholds)
+        msg = str(ctx.exception)
+        self.assertIn("value is None", msg)
+        self.assertIn("client.total_token_throughput", msg)
+
+    def test_non_none_actual_still_evaluated_normally(self):
+        # A satisfied threshold must still pass (guard is None-specific).
+        actuals = {"client.goodput": 5.0}
+        thresholds = {"client.goodput": {"kind": "min", "value": 1.0}}
+        evaluate_all(actuals, thresholds)  # no raise
+
+
+class TestTableCellRendering(unittest.TestCase):
+    """Regression (code-review F1): a metric that is present-but-None (goodput
+    with no SLO run, a derived ratio with no p50) must render as "-" in the
+    results table, not the literal "None" (m.get returns None when the key
+    exists)."""
+
+    def _cell(self):
+        import importlib.util
+        import sys as _sys
+        from types import ModuleType
+
+        # _shared.py imports tabulate at module scope; the _cell helper does not
+        # need it. Stub it so the module loads in the bare unittest interpreter.
+        _sys.modules.setdefault("tabulate", ModuleType("tabulate"))
+        if not hasattr(_sys.modules["tabulate"], "tabulate"):
+            _sys.modules["tabulate"].tabulate = lambda *a, **k: ""
+        spec = importlib.util.spec_from_file_location("_shared_under_test", str(_SHARED))
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod._cell
+
+    def test_present_but_none_renders_dash(self):
+        cell = self._cell()
+        self.assertEqual(cell({"client.goodput": None}, "client.goodput"), "-")
+
+    def test_absent_key_renders_dash(self):
+        cell = self._cell()
+        self.assertEqual(cell({}, "client.goodput"), "-")
+
+    def test_real_value_passes_through(self):
+        cell = self._cell()
+        self.assertEqual(cell({"client.goodput": 4.76}, "client.goodput"), 4.76)
+
+    def test_zero_is_not_dashed(self):
+        # 0.0 is a real measurement, must NOT become '-'.
+        cell = self._cell()
+        self.assertEqual(cell({"client.request_throughput": 0.0}, "client.request_throughput"), 0.0)
+
+
+class TestVerdictMinRatioReferenceNone(unittest.TestCase):
+    """Regression (code-review F2): min_ratio dereferences a SECOND (reference)
+    metric; if that reference is a None-valued derived metric, evaluate_all must
+    raise a clean ThresholdViolation, not float(None) TypeError."""
+
+    def test_min_ratio_none_reference_raises_violation_not_typeerror(self):
+        actuals = {"client.per_gpu_throughput": 1000.0, "client.decode_latency_ratio": None}
+        thresholds = {
+            "client.per_gpu_throughput": {
+                "kind": "min_ratio",
+                "reference": "client.decode_latency_ratio",
+                "value": 0.5,
+            }
+        }
+        with self.assertRaises(ThresholdViolation) as ctx:
+            evaluate_all(actuals, thresholds)
+        self.assertIn("is None", str(ctx.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+
+class TestDerivedMaxModelLen(unittest.TestCase):
+    """MAX_MODEL_LEN is derived per cell from isl/osl/random_range_ratio/random_prefix_len,
+    not read from config. Worst-case sequence = (isl+osl)*(1+r) + prefix; +pad for rounding."""
+
+    def _env_cmd(self, job):
+        orch = FakeOrch()
+        job.orch = orch
+        job.build_server_cmd()
+        # build_server_cmd issues: printf the env script, then mkdir the out-dir.
+        # The env script (with MAX_MODEL_LEN) is in the first exec.
+        return orch.commands[0]
+
+    def test_derived_value_for_default_cell(self):
+        # isl=128, osl=2048, r=0.8, prefix=0 -> ceil(2176*1.8)=3917, +0 +8 = 3925.
+        job = _make_job(FakeOrch())
+        self.assertEqual(job._derive_max_model_len(), "3925")
+
+    def test_low_ratio_shrinks_window(self):
+        # Dropping the ratio must shrink the derived window automatically.
+        job = _make_job(FakeOrch())
+        job.random_range_ratio = "0.1"
+        # ceil(2176*1.1)=2394, +0 +8 = 2402.
+        self.assertEqual(job._derive_max_model_len(), "2402")
+
+    def test_zero_ratio_is_fixed_length_plus_pad(self):
+        job = _make_job(FakeOrch())
+        job.random_range_ratio = "0.0"
+        # (128+2048) + 0 + 8 = 2184.
+        self.assertEqual(job._derive_max_model_len(), "2184")
+
+    def test_prefix_len_added(self):
+        job = _make_job(FakeOrch())
+        job.random_range_ratio = "0.0"
+        job.random_prefix_len = "64"
+        # 2176 + 64 + 8 = 2248.
+        self.assertEqual(job._derive_max_model_len(), "2248")
+
+    def test_server_argv_carries_derived_value(self):
+        # The derived max-model-len is passed as the --max-model-len flag on the
+        # `vllm serve` argv (it is no longer exported into the env script).
+        job = _make_job(FakeOrch())
+        argv = job._server_argv()
+        self.assertIn("--max-model-len", argv)
+        self.assertEqual(argv[argv.index("--max-model-len") + 1], "3925")
+
+
+import importlib.util as _ilu_t
+
+_VS_PATH = _REPO / "cvs/tests/inference/vllm/vllm_single.py"
+
+
+def _load_vllm_single():
+    """Import the suite module standalone to reach _METRICS and test_metric.
+
+    The module's only collection-time work is a top-level importlib exec of the
+    sibling _shared.py; everything else is function/constant defs, so importing it
+    outside pytest is safe and hardware-free.
+    """
+    spec = _ilu_t.spec_from_file_location("_vllm_single_under_test", str(_VS_PATH))
+    mod = _ilu_t.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+class _FakeNode:
+    def __init__(self):
+        self.user_properties = []
+
+
+class _FakeRequest:
+    def __init__(self):
+        self.node = _FakeNode()
+
+
+class _FakeLifecycle:
+    def __init__(self, failed=False):
+        self.failed = failed
+
+
+def _fake_variant_config(enforce=False, thresholds=None):
+    """Stand-in carrying exactly what test_metric reads: model.id, gpu_arch,
+    enforce_thresholds, thresholds, and the real cell_key builder."""
+    params = SimpleNamespace(tensor_parallelism=str(_TP))
+    vc = SimpleNamespace(
+        model=SimpleNamespace(id="amd/Llama-3.1-70B-Instruct-FP8-KV"),
+        gpu_arch="mi300x",
+        params=params,
+        enforce_thresholds=enforce,
+        thresholds=thresholds or {},
+    )
+    vc.cell_key = lambda isl, osl, conc: f"ISL={isl},OSL={osl},TP={params.tensor_parallelism},CONC={conc}"
+    return vc
+
+
+class TestMetricTests(unittest.TestCase):
+    """test_metric is the per-metric pytest row. These exercise its three paths
+    (cell-missing skip, record-only PASS, enforced violation) with fakes -- no
+    hardware, no real pytest collection."""
+
+    def setUp(self):
+        self.vs = _load_vllm_single()
+        # A realistic per-cell actuals dict, as test_vllm_inference would stash.
+        orch = FakeOrch({"fakehost": _load_fixture("vllm_results_widened.json")})
+        self.actuals = _make_job(orch).parse_results()["fakehost"]
+        self.seq_combo = {"isl": "128", "osl": "2048", "name": "throughput"}
+        self.conc = 64
+        self.key = ("amd/Llama-3.1-70B-Instruct-FP8-KV", "mi300x", "128", "2048", "throughput", 64)
+
+    def test_every_metric_key_is_produced(self):
+        """Every _METRICS short name must resolve to a client.* key parse_results
+        emits -- otherwise its row would silently show '-'."""
+        produced = set(self.actuals.keys())
+        missing = [short for short, _u in self.vs._METRICS if ("client." + short) not in produced]
+        self.assertEqual(missing, [], f"_METRICS names with no producer: {missing}")
+
+    def test_gated_metrics_are_all_produced_and_displayed(self):
+        """Every GATED_METRICS name must be both produced (parse_results emits
+        client.<name>) and displayed (in _METRICS) -- a gated metric with no
+        producer would gate a '-', and one absent from _METRICS would assert a
+        value that never appears in the report."""
+        from cvs.lib.inference.utils.vllm_parsing import GATED_METRICS
+        produced = set(self.actuals.keys())
+        displayed = {short for short, _u in self.vs._METRICS}
+        no_producer = sorted(m for m in GATED_METRICS if ("client." + m) not in produced)
+        no_row = sorted(m for m in GATED_METRICS if m not in displayed)
+        self.assertEqual(no_producer, [], f"gated metrics with no producer: {no_producer}")
+        self.assertEqual(no_row, [], f"gated metrics not in _METRICS: {no_row}")
+
+    def test_skips_when_cell_absent(self):
+        import pytest as _pt
+        with self.assertRaises(_pt.skip.Exception):
+            self.vs.test_metric(
+                self.seq_combo, self.conc, "p99_e2el_ms",
+                {}, _fake_variant_config(), _FakeLifecycle(), _FakeRequest(),
+            )
+
+    def test_skips_when_lifecycle_failed(self):
+        import pytest as _pt
+        with self.assertRaises(_pt.skip.Exception):
+            self.vs.test_metric(
+                self.seq_combo, self.conc, "p99_e2el_ms",
+                {self.key: {"fakehost": self.actuals}},
+                _fake_variant_config(), _FakeLifecycle(failed=True), _FakeRequest(),
+            )
+
+    def test_record_only_records_value_and_unit(self):
+        req = _FakeRequest()
+        self.vs.test_metric(
+            self.seq_combo, self.conc, "p99_e2el_ms",
+            {self.key: {"fakehost": self.actuals}},
+            _fake_variant_config(enforce=False), _FakeLifecycle(), req,
+        )
+        props = dict(req.node.user_properties)
+        self.assertEqual(props["metric_value"], self.actuals["client.p99_e2el_ms"])
+        self.assertEqual(props["metric_unit"], "ms")
+
+    def test_enforce_raises_on_violation(self):
+        # mean_ttft_ms is ~hundreds; a max_ms of 1.0 must trip evaluate_all.
+        cell = f"ISL=128,OSL=2048,TP={_TP},CONC=64"
+        thr = {cell: {"client.mean_ttft_ms": {"kind": "max_ms", "value": 1.0}}}
+        with self.assertRaises(ThresholdViolation):
+            self.vs.test_metric(
+                self.seq_combo, self.conc, "mean_ttft_ms",
+                {self.key: {"fakehost": self.actuals}},
+                _fake_variant_config(enforce=True, thresholds=thr), _FakeLifecycle(), _FakeRequest(),
+            )
+
+    def test_enforce_no_spec_is_record_only(self):
+        # enforce=true but no threshold for this metric -> record-only, no raise.
+        req = _FakeRequest()
+        self.vs.test_metric(
+            self.seq_combo, self.conc, "p95_tpot_ms",
+            {self.key: {"fakehost": self.actuals}},
+            _fake_variant_config(enforce=True, thresholds={}), _FakeLifecycle(), req,
+        )
+        self.assertEqual(dict(req.node.user_properties)["metric_unit"], "ms")
+
+
+from cvs.lib.inference.utils.vllm_parsing import _safe_div, to_client_metrics
+
+
+class TestToClientMetricsPure(unittest.TestCase):
+    """Direct tests of the pure transform -- no FakeOrch, no VllmJob.
+
+    parse_results already covers the wiring; these pin the vocabulary + math in
+    isolation so distributed/disagg/InferenceMax reuse rests on a tested seam.
+    """
+
+    def setUp(self):
+        self.raw = json.loads(_load_fixture("vllm_results_widened.json"))
+
+    def test_namespaces_every_stock_scalar(self):
+        m = to_client_metrics(self.raw, tp=_TP, isl=_ISL)
+        for k, v in self.raw.items():
+            self.assertEqual(m[f"client.{k}"], v)
+
+    def test_goodput_alias(self):
+        m = to_client_metrics(self.raw, tp=_TP, isl=_ISL)
+        self.assertEqual(m["client.goodput"], self.raw["request_goodput"])
+
+    def test_derived_metrics_exact(self):
+        m = to_client_metrics(self.raw, tp=_TP, isl=_ISL)
+        w = self.raw
+        self.assertAlmostEqual(m["client.per_gpu_throughput"], w["total_token_throughput"] / _TP)
+        self.assertAlmostEqual(m["client.normalized_ttft_ms_per_tok"], w["mean_ttft_ms"] / _ISL)
+        self.assertAlmostEqual(m["client.decode_latency_ratio"], w["p99_itl_ms"] / w["p50_itl_ms"])
+        self.assertAlmostEqual(m["client.decode_throughput_p50"], 1000.0 / w["median_tpot_ms"])
+        self.assertAlmostEqual(m["client.success_rate"], w["completed"] / (w["completed"] + w["failed"]))
+
+    def test_pure_no_mutation_of_input(self):
+        snapshot = dict(self.raw)
+        to_client_metrics(self.raw, tp=_TP, isl=_ISL)
+        self.assertEqual(self.raw, snapshot)
+
+    def test_missing_inputs_degrade_to_none_not_raise(self):
+        m = to_client_metrics({}, tp=_TP, isl=_ISL)
+        for d in ("per_gpu_throughput", "normalized_ttft_ms_per_tok",
+                  "decode_latency_ratio", "decode_throughput_p50", "success_rate"):
+            self.assertIsNone(m[f"client.{d}"])
+
+
+class TestSafeDivPure(unittest.TestCase):
+    def test_normal(self):
+        self.assertEqual(_safe_div(10, 2), 5.0)
+
+    def test_zero_divisor_is_none(self):
+        self.assertIsNone(_safe_div(1, 0))
+
+    def test_none_operands_are_none(self):
+        self.assertIsNone(_safe_div(None, 2))
+        self.assertIsNone(_safe_div(2, None))
+
+    def test_non_numeric_is_none(self):
+        self.assertIsNone(_safe_div("x", 2))
diff --git a/cvs/lib/inference/utils/AGENTS.md b/cvs/lib/inference/utils/AGENTS.md
new file mode 100644
index 00000000..81369efc
--- /dev/null
+++ b/cvs/lib/inference/utils/AGENTS.md
@@ -0,0 +1,106 @@
+# cvs/lib/inference/utils — inference-specific helpers
+
+The inference half of the config/parsing machinery. Generic machinery
+(`BaseVariantConfig`, placeholder substitution, `substitute_config`,
+`evaluate_all`) lives one level up in `cvs/lib/utils/` — import from there, don't
+duplicate it. This dir holds what's specific to *serving* workloads: the sweep
+schema and the vLLM client-metric vocabulary.
+
+## What's here
+
+- `inferencing_config_loader.py` — the vLLM config schema (`VariantConfig`, sweep, `load_variant`).
+- `inferencemax_config_loader.py` — the InferenceMax config schema (`InferenceMaxVariantConfig`, `InferenceMaxParams`, `load_variant`, `orchestrator_container_from_variant`).
+- `vllm_parsing.py` — pure parsers for vLLM benchmark artifacts:
+  `to_client_metrics()`, the `client.*` namespace, `CLIENT_METRICS` (the
+  display surface), and `GATED_METRICS` (the asserted SLO subset).
+
+## Public entry points
+
+- `inferencing_config_loader.load_variant(...) -> VariantConfig` — vLLM suite loader.
+- `inferencemax_config_loader.load_variant(...) -> InferenceMaxVariantConfig` — InferenceMax suite loader.
+- `to_client_metrics(raw, *, tp, isl) -> {client.*: value}`
+  Maps a stock `vllm bench serve` results dict to the namespaced metric dict.
+  **Pure** — no I/O, no orchestration. Caller fetches + json-loads the artifact.
+- `CLIENT_METRICS` / `CLIENT_METRIC_UNITS`
+  The ordered `(short_name, unit)` list that becomes one HTML row per metric. The
+  single definition every vLLM flavour (single-node, distributed, disagg,
+  InferenceMax) shares — don't re-list rows per suite.
+- `GATED_METRICS`
+  The asserted subset of `CLIENT_METRICS`: the perf+health SLO contract a
+  calibrated run must *assert*, not merely display. Membership = "out of range
+  means FAILURE". Today: throughput (total + per-request output), the full
+  latency distribution (mean/median/p90/p95/p99 per ttft/tpot/itl/e2el — itl has
+  no p90 producer), and run health (`success_rate` floor, `failed` ceiling).
+  Closed-world default: a new metric is record-only until its name is added
+  here, at which point the loader forces a spec for it in every cell.
+- `GoodputSlo`, `SeqCombo`, `Run`, `Sweep`, `Params`, `Roles`, `VariantConfig` —
+  the typed schema.
+
+## The sweep selector (the headline design point)
+
+The old schema expanded `sequence_combinations × concurrency_levels` into an NxM
+cartesian. This replaces it with **named combos + an explicit `runs[]` list**:
+
+```json
+"sweep": {
+  "sequence_combinations": [ {"name": "w1_isl=128_osl=2048", "isl":"128", "osl":"2048", ...} ],
+  "runs": [ {"combo": "w1_isl=128_osl=2048", "concurrency": 16} ]
+}
+```
+
+Each `run` is one `(combo, concurrency)` cell — you enumerate exactly the cells
+you want, no explosion. `Sweep`'s `@model_validator` rejects duplicate combo
+names and any `run.combo` that names no combo, **at load time**.
+
+## Gotchas worth not re-discovering
+
+- **`cell_key` is the single source of truth** for a cell's threshold key
+  (`ISL=…,OSL=…,TP=…,CONC=…`). The loader's coverage check and the test's verdict
+  lookup both call it, so they can't drift on whitespace/ordering. If you change
+  the key format, everything keyed on it (threshold.json, `expected_cells`) moves
+  together — change it in one place.
+- **`_check_thresholds_cover_sweep` is what prevents a silent green.** It checks
+  two axes: (1) cell coverage — every sweep cell has a threshold entry, no key
+  names a non-existent cell; (2) gated-metric coverage — every present cell
+  carries a spec for every `GATED_METRICS` member. Without (1) a mistyped key
+  makes the test skip its verdict; without (2) a gated metric with no spec falls
+  through `test_metric`'s record-only branch and reports PASS with zero
+  assertions even under `enforce_thresholds=true`. When `enforce_thresholds=false`
+  both are *warnings* (record-only mode), not errors — intentional for
+  un-calibrated configs, not a bug to "fix".
+- **`pytest_generate_tests` reads raw JSON and bypasses this loader** (it runs at
+  collection time, before fixtures exist). So the validators here are
+  **mirrored** by hand in the suite's `pytest_generate_tests` (dup-name check,
+  unknown-combo check, `GoodputSlo(**…)` validation). If you add a validator to
+  `Sweep`, mirror it there too or collection won't enforce it.
+- **`GoodputSlo` is an INPUT, not a threshold.** It's passed to
+  `vllm bench serve --goodput`; it lives in the sweep, not threshold.json.
+  Per-combo because e2el scales with osl. `_Forbid`, so a typo'd SLO key fails
+  load rather than silently dropping the gate.
+- **`to_client_metrics` is deliberately I/O-free.** Artifact layout is
+  job-specific (single-node `cat`, disagg prefill+decode, distributed rank-0);
+  the *fetch* lives in the orchestrator (`vllm_orch.parse_results`), the
+  *transform* lives here so every job reuses it. Keep it that way — don't add
+  file reads here.
+- **Derived metrics degrade to `None`, never crash.** `_safe_div` returns `None`
+  on missing/None/zero-divisor. `evaluate_all` then reports `None` as a loud
+  violation (not a `float(None)` TypeError). A metric the run couldn't produce
+  shows `-` in the table, not a stack trace.
+- **`client.goodput` is an alias** for stock's `request_goodput` (the name the
+  table + threshold file use). Stock leaves `request_goodput` null unless
+  `--goodput` was passed.
+- **`Params` is the only framework-flavoured schema class** (it's the `vllm bench
+  serve` flag set). `Sweep`/`SeqCombo`/`GoodputSlo`/`Roles`/`cell_key` are
+  serving-generic. When a second serving framework lands, subclass `Params`; the
+  rest is reusable as-is.
+
+## When extending
+
+- New `client.*` metric → add the derivation in `to_client_metrics` (guard
+  divisors with `_safe_div`) AND a `(name, unit)` entry in `CLIENT_METRICS`. If
+  it's a pass/fail criterion, also add it to `GATED_METRICS` (then every cell's
+  threshold.json needs a spec for it) — otherwise it stays record-only.
+- New combo field → add to `SeqCombo` (`_Forbid`, so also update any raw-JSON
+  reader like `pytest_generate_tests`).
+- Second framework → subclass `Params`; reuse everything else here and
+  `BaseVariantConfig`/`substitute_config` from `cvs/lib/utils/`.
diff --git a/cvs/lib/dtni/__init__.py b/cvs/lib/inference/utils/__init__.py
similarity index 100%
rename from cvs/lib/dtni/__init__.py
rename to cvs/lib/inference/utils/__init__.py
diff --git a/cvs/lib/inference/utils/inferencemax_config_loader.py b/cvs/lib/inference/utils/inferencemax_config_loader.py
new file mode 100644
index 00000000..a5e36e60
--- /dev/null
+++ b/cvs/lib/inference/utils/inferencemax_config_loader.py
@@ -0,0 +1,146 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+InferenceMax suite config schema (``framework: inferencemax_single``).
+
+Generic paths/model/container/threshold plumbing lives in
+:mod:`cvs.lib.utils.config_loader`. Sweep selector types are shared with
+:mod:`cvs.lib.inference.utils.inferencing_config_loader`.
+'''
+
+from __future__ import annotations
+
+import warnings
+from typing import Any, Dict, List
+
+from pydantic import model_validator
+from typing_extensions import Literal
+
+from cvs.lib.inference.utils.inferencing_config_loader import (
+    Roles,
+    Sweep,
+)
+from cvs.lib.inference.utils.vllm_parsing import GATED_METRICS
+from cvs.lib.utils.config_loader import BaseVariantConfig, _Forbid, substitute_config
+
+
+class InferenceMaxParams(_Forbid):
+    backend: str = "vllm"
+    base_url: str = "http://0.0.0.0"
+    port_no: str = "8000"
+    dataset_name: str = "random"
+    burstiness: str = "1.0"
+    seed: str = "0"
+    request_rate: str = "inf"
+    random_range_ratio: str = "0.8"
+    random_prefix_len: str = "0"
+    tensor_parallelism: str = "8"
+    tokenizer_mode: str = "auto"
+    percentile_metrics: str = "ttft,tpot,itl,e2el"
+    metric_percentiles: str = "99"
+    num_prompts: str = "1000"
+    max_model_length: str = "8192"
+    client_poll_count: str = "50"
+    client_poll_wait_time: str = "60"
+    bench_max_failed_requests: str = "0"
+
+
+class InferenceMaxVariantConfig(BaseVariantConfig):
+    framework: Literal["inferencemax_single"]
+    gpu_arch: str
+    roles: Roles = Roles()
+    params: InferenceMaxParams
+    sweep: Sweep
+
+    def cell_key(self, isl, osl, concurrency):
+        return f"ISL={isl},OSL={osl},TP={self.params.tensor_parallelism},CONC={concurrency}"
+
+    def expected_cells(self) -> List[str]:
+        by_name = {c.name: c for c in self.sweep.sequence_combinations}
+        return [
+            self.cell_key(by_name[r.combo].isl, by_name[r.combo].osl, r.concurrency)
+            for r in self.sweep.runs
+        ]
+
+    @model_validator(mode="after")
+    def _check_thresholds_cover_sweep(self):
+        expected = set(self.expected_cells())
+        present = set(self.thresholds.keys())
+        missing = sorted(expected - present)
+        extra = sorted(present - expected)
+        problems = []
+        if missing:
+            problems.append(f"sweep cells with no threshold entry: {missing}")
+        if extra:
+            problems.append(f"threshold keys matching no sweep cell (typo?): {extra}")
+        gated_keys = [f"client.{m}" for m in sorted(GATED_METRICS)]
+        gated_gaps = {}
+        for cell in sorted(expected & present):
+            specs = self.thresholds.get(cell) or {}
+            absent = [k for k in gated_keys if k not in specs]
+            if absent:
+                gated_gaps[cell] = absent
+        if gated_gaps:
+            problems.append(f"cells missing gated-metric specs: {gated_gaps}")
+        if problems:
+            msg = "threshold.json does not match the sweep matrix; " + "; ".join(problems)
+            if self.enforce_thresholds:
+                raise ValueError(msg)
+            warnings.warn(f"{msg} (enforce_thresholds=false -> record-only)", stacklevel=2)
+        return self
+
+
+def load_variant(config_path, cluster_dict) -> InferenceMaxVariantConfig:
+    """Load and validate an InferenceMax variant config + sibling ``*threshold.json``."""
+    raw, thresholds = substitute_config(config_path, cluster_dict)
+    raw["thresholds"] = thresholds
+    return InferenceMaxVariantConfig(**raw)
+
+
+def placeholder_gated_threshold_cell(
+    *,
+    output_throughput_min: float = 0,
+    mean_ttft_max_ms: float = 1_000_000,
+    mean_tpot_max_ms: float = 1_000_000,
+    failed_max: int = 1_000_000_000,
+    success_rate_min: float = 0,
+) -> Dict[str, Any]:
+    """Return one sweep cell's ``client.*`` specs covering every ``GATED_METRICS`` member."""
+    loose_ms = {"kind": "max_ms", "value": 1_000_000}
+    loose_tok = {"kind": "min_tok_s", "value": 0}
+    return {
+        "client.total_token_throughput": loose_tok,
+        "client.output_throughput": {"kind": "min_tok_s", "value": output_throughput_min},
+        "client.mean_ttft_ms": {"kind": "max_ms", "value": mean_ttft_max_ms},
+        "client.median_ttft_ms": loose_ms,
+        "client.p90_ttft_ms": loose_ms,
+        "client.p95_ttft_ms": loose_ms,
+        "client.p99_ttft_ms": loose_ms,
+        "client.mean_tpot_ms": {"kind": "max_ms", "value": mean_tpot_max_ms},
+        "client.median_tpot_ms": loose_ms,
+        "client.p90_tpot_ms": loose_ms,
+        "client.p95_tpot_ms": loose_ms,
+        "client.p99_tpot_ms": loose_ms,
+        "client.mean_itl_ms": loose_ms,
+        "client.median_itl_ms": loose_ms,
+        "client.p95_itl_ms": loose_ms,
+        "client.p99_itl_ms": loose_ms,
+        "client.mean_e2el_ms": loose_ms,
+        "client.median_e2el_ms": loose_ms,
+        "client.p90_e2el_ms": loose_ms,
+        "client.p95_e2el_ms": loose_ms,
+        "client.p99_e2el_ms": loose_ms,
+        "client.p99_e2el_ms": loose_ms,
+        "client.success_rate": {"kind": "min", "value": success_rate_min},
+        "client.failed": {"kind": "max", "value": failed_max},
+    }
+
+
+def orchestrator_container_from_variant(variant: InferenceMaxVariantConfig) -> Dict[str, Any]:
+    """``container`` block for :class:`OrchestratorConfig` (includes server env)."""
+    block = variant.container.model_dump()
+    server_env = variant.roles.server.env
+    if server_env:
+        block = {**block, "env": dict(server_env)}
+    return block
diff --git a/cvs/lib/inference/utils/inferencing_config_loader.py b/cvs/lib/inference/utils/inferencing_config_loader.py
new file mode 100644
index 00000000..d5bf6ac1
--- /dev/null
+++ b/cvs/lib/inference/utils/inferencing_config_loader.py
@@ -0,0 +1,219 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Inference-specific config schema for the vllm_single suite.
+
+The framework-agnostic machinery (paths/model/image/container schema, the
+3-pass placeholder substitution, the `enforce_thresholds` gate, and the
+`substitute_config` file-read helper) lives in `cvs.lib.utils.config_loader`.
+This module holds the inference half: the sweep selector
+(`SeqCombo`/`Run`/`Sweep`), the goodput SLO, the framework `Params`, the
+`server` role, and `VariantConfig(BaseVariantConfig)` with the
+ISL/OSL/TP/CONC `cell_key` and its sweep-coverage check.
+
+`Sweep`/`SeqCombo`/`GoodputSlo`/`Roles`/`cell_key` are inference-generic (any
+serving framework sweeps sequence shapes at concurrencies); only `Params` (the
+`vllm bench serve` flags) is framework-flavored and is the seam to subclass
+when a second serving framework lands.
+'''
+
+from __future__ import annotations
+
+import warnings
+from typing import Any, Dict, List, Optional
+
+from pydantic import model_validator
+from typing_extensions import Literal
+
+from cvs.lib.utils.config_loader import BaseVariantConfig, _Forbid, substitute_config
+from cvs.lib.inference.utils.vllm_parsing import GATED_METRICS
+
+
+# ---------- pydantic models (inference) ----------
+
+
+class RoleServer(_Forbid):
+    # The `vllm serve` command is built in Python (cvs.lib.inference.vllm_orch),
+    # not cloned from a `.sh` script, so a run is self-contained. Per-model
+    # server quirks live here: extra `vllm serve` flags (serve_args) and env vars
+    # merged over the defaults the orchestrator sets. Both default empty; the
+    # fp8-kv cell sets its --kv-cache-dtype via serve_args, kept out of the
+    # generic driver so it stays model-agnostic. A {flag: value} map (flag
+    # without the leading --): a scalar renders `--flag value`, True renders a
+    # bare `--flag`, and a list renders the flag once per element. Cleaner than
+    # a flat [flag, value, flag, value] list and still covers vllm's bare and
+    # repeatable flags.
+    serve_args: Dict[str, Any] = {}
+    env: Dict[str, str] = {}
+
+
+class Roles(_Forbid):
+    server: RoleServer = RoleServer()
+
+
+class GoodputSlo(_Forbid):
+    # Per-cell SLOs for the goodput gate, in milliseconds. An INPUT to the run
+    # (passed to `vllm bench serve --goodput`), NOT a threshold to assert -- so
+    # it lives in the sweep, not threshold.json. Attached per seq_combo because
+    # e2el scales ~linearly with osl. _Forbid: a typo'd key fails load, not a
+    # silently-dropped SLO.
+    ttft_ms: float
+    tpot_ms: float
+    e2el_ms: float
+
+
+class SeqCombo(_Forbid):
+    # `name` is the join key the `runs` selector references; required.
+    name: str
+    isl: str
+    osl: str
+    goodput_slo: Optional[GoodputSlo] = None
+
+
+class Run(_Forbid):
+    # One sweep cell: a named combo run at a single concurrency. The explicit
+    # list of Runs replaces the old `sequence_combinations x concurrency_levels`
+    # cartesian -- you enumerate exactly the cells you want, no NxM explosion.
+    combo: str
+    concurrency: int
+
+
+def validate_sweep_selector(combo_names, run_combo_refs):
+    """The sweep-selector rule: combo names unique, every run.combo names one.
+
+    The single home for this check, shared by the typed `Sweep` validator (load
+    time) and `pytest_generate_tests` (collection time, which reads raw JSON
+    before the loader runs) so the two can never drift. Operates on plain lists
+    of strings so both call sites can feed it.
+
+    Without it a duplicate name silently shadows a combo and a typo'd
+    `run.combo` is a silently-dropped cell -- either way the sweep runs a
+    different matrix than the config reads.
+    """
+    names = list(combo_names)
+    dupes = sorted({n for n in names if names.count(n) > 1})
+    if dupes:
+        raise ValueError(f"duplicate sequence_combination names: {dupes}")
+    known = set(names)
+    unknown = sorted({r for r in run_combo_refs if r not in known})
+    if unknown:
+        raise ValueError(f"run.combo names no sequence_combination: {unknown} (known: {sorted(known)})")
+
+
+class Sweep(_Forbid):
+    sequence_combinations: List[SeqCombo]
+    runs: List[Run]
+
+    @model_validator(mode="after")
+    def _check_runs_reference_known_combos(self):
+        validate_sweep_selector(
+            [c.name for c in self.sequence_combinations],
+            [r.combo for r in self.runs],
+        )
+        return self
+
+
+class Params(_Forbid):
+    backend: str = "vllm"
+    base_url: str = "http://0.0.0.0"
+    port_no: str = "8888"
+    dataset_name: str = "random"
+    burstiness: str = "1.0"
+    seed: str = "0"
+    request_rate: str = "inf"
+    random_range_ratio: str = "0.8"
+    random_prefix_len: str = "0"
+    tensor_parallelism: str = "1"
+    tokenizer_mode: str = "auto"
+    percentile_metrics: str = "ttft,tpot,itl,e2el"
+    metric_percentiles: str = "50,90,95,99"
+    num_prompts: str = "3200"
+    # Completion-poll budget for the bench client = client_poll_count * 60s
+    # (plus a 120s initial wait). Large-output cells (high osl) need a bigger
+    # budget; the poll loop exits as soon as the client finishes, so raising
+    # this never slows down fast cells. See regressions REG-20260609-001.
+    client_poll_count: str = "20"
+
+
+class VariantConfig(BaseVariantConfig):
+    framework: Literal["vllm_single"]
+    gpu_arch: str
+    roles: Roles = Roles()
+    params: Params
+    sweep: Sweep
+
+    def cell_key(self, isl, osl, concurrency):
+        """The canonical threshold key for one sweep cell.
+
+        Single source of truth shared by the loader's coverage check and the
+        test's verdict lookup -- so the two can never drift on whitespace,
+        ordering, or field names.
+        """
+        return f"ISL={isl},OSL={osl},TP={self.params.tensor_parallelism},CONC={concurrency}"
+
+    def expected_cells(self):
+        """Every (isl, osl, conc) cell the sweep's `runs` selector picks."""
+        by_name = {c.name: c for c in self.sweep.sequence_combinations}
+        return [
+            self.cell_key(by_name[r.combo].isl, by_name[r.combo].osl, r.concurrency)
+            for r in self.sweep.runs
+        ]
+
+    @model_validator(mode="after")
+    def _check_thresholds_cover_sweep(self):
+        """Fail at load time if any sweep cell lacks a threshold entry.
+
+        Two axes are checked. (1) Cell coverage: every sweep cell has a
+        threshold entry, and no threshold key names a cell the sweep does not
+        run. (2) Gated-metric coverage: every present cell carries a spec for
+        every GATED_METRICS member -- the SLO contract. Without (2) a gated
+        metric with no spec falls through `test_metric`'s `spec is None`
+        record-only branch and reports a green PASS with zero assertions, even
+        under enforce_thresholds=true.
+
+        When `enforce_thresholds` is false the same mismatch is reported as a
+        warning rather than an error -- the config loads as a record-only
+        scaffold (metrics captured, no assertions) instead of failing.
+        """
+        expected = set(self.expected_cells())
+        present = set(self.thresholds.keys())
+        missing = sorted(expected - present)
+        extra = sorted(present - expected)
+        problems = []
+        if missing:
+            problems.append(f"sweep cells with no threshold entry: {missing}")
+        if extra:
+            problems.append(f"threshold keys matching no sweep cell (typo?): {extra}")
+        # Gated-metric coverage, only for cells that are present (a wholly
+        # missing cell is already reported above -- do not double-report it).
+        gated_keys = [f"client.{m}" for m in sorted(GATED_METRICS)]
+        gated_gaps = {}
+        for cell in sorted(expected & present):
+            specs = self.thresholds.get(cell) or {}
+            absent = [k for k in gated_keys if k not in specs]
+            if absent:
+                gated_gaps[cell] = absent
+        if gated_gaps:
+            problems.append(f"cells missing gated-metric specs: {gated_gaps}")
+        if problems:
+            msg = "threshold.json does not match the sweep matrix; " + "; ".join(problems)
+            if self.enforce_thresholds:
+                raise ValueError(msg)
+            warnings.warn(f"{msg} (enforce_thresholds=false -> record-only)", stacklevel=2)
+        return self
+
+
+# ---------- public API (inference) ----------
+
+
+def load_variant(config_path, cluster_dict):
+    """Load and validate a vllm_single variant config + its sibling threshold file.
+
+    Delegates the file read + placeholder substitution + threshold discovery to
+    the generic `substitute_config`, then attaches the thresholds and builds the
+    typed `VariantConfig`.
+    """
+    raw, thresholds = substitute_config(config_path, cluster_dict)
+    raw["thresholds"] = thresholds
+    return VariantConfig(**raw)
diff --git a/cvs/lib/inference/utils/vllm_parsing.py b/cvs/lib/inference/utils/vllm_parsing.py
new file mode 100644
index 00000000..c53c1fba
--- /dev/null
+++ b/cvs/lib/inference/utils/vllm_parsing.py
@@ -0,0 +1,173 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Pure parsers for vLLM benchmark artifacts.
+
+This module owns the *vocabulary and math* of vLLM metrics -- the mapping from
+a raw benchmark artifact to the namespaced metric dict that downstream code
+(threshold files, the per-metric HTML rows, `evaluate_all`) keys on. It is
+deliberately free of I/O and orchestration: callers fetch the bytes (each job
+lays its artifacts out differently -- single-node `cat`, disagg prefill+decode,
+distributed rank-0 vs all-ranks) and hand the parsed/raw payload in here.
+
+Keeping the transforms pure makes them reusable across jobs (single-node,
+distributed, disaggregated, InferenceMax) and unit-testable with plain
+dict/string fixtures -- no fake orchestrator required.
+
+Namespacing contract:
+  - `client.*`  -- scalars measured by the load generator (`vllm bench serve`).
+  - `server.*`  -- scalars scraped from the live server `/metrics` endpoint
+                   (future; `to_server_metrics` will live here too).
+'''
+
+from __future__ import annotations
+
+
+def _safe_div(num, den):
+    """num/den, or None if either is missing/None or the divisor is 0.
+
+    Derived metrics must degrade to None (a clean "not available"), never a
+    bogus 0 or a KeyError that would crash an otherwise-good run.
+    """
+    if num is None or den is None:
+        return None
+    try:
+        den = float(den)
+        if den == 0:
+            return None
+        return float(num) / den
+    except (TypeError, ValueError):
+        return None
+
+
+def to_client_metrics(raw, *, tp, isl):
+    """Map a stock `vllm bench serve` results dict to the `client.*` namespace.
+
+    `raw` is the already-parsed JSON the load generator writes to its
+    `--result-dir` `results` artifact. Every stock scalar is namespaced
+    `client.<key>` 1:1, then a few derived metrics are appended. Pure: no I/O,
+    no orchestration -- the caller is responsible for fetching and json-loading
+    the artifact and for raising on missing/unparseable input.
+
+    `tp` (tensor parallelism) and `isl` (input sequence length) are the only
+    out-of-band scalars the derivations need.
+    """
+    m = {f"client.{k}": v for k, v in raw.items()}
+    # Friendly alias: stock's request_goodput -> client.goodput
+    # (the name the results table and threshold file reference).
+    m["client.goodput"] = raw.get("request_goodput")
+
+    # Derived metrics. _safe_div guards every divisor (0/None/missing).
+    ttot = raw.get("total_token_throughput")
+    mean_ttft = raw.get("mean_ttft_ms")
+    p99_itl = raw.get("p99_itl_ms")
+    p50_itl = raw.get("p50_itl_ms")
+    median_tpot = raw.get("median_tpot_ms")
+    completed = raw.get("completed")
+    failed = raw.get("failed")
+
+    m["client.per_gpu_throughput"] = _safe_div(ttot, tp)
+    m["client.normalized_ttft_ms_per_tok"] = _safe_div(mean_ttft, isl)
+    m["client.decode_latency_ratio"] = _safe_div(p99_itl, p50_itl)
+    m["client.decode_throughput_p50"] = _safe_div(1000.0, median_tpot)
+    total_req = None if completed is None or failed is None else completed + failed
+    m["client.success_rate"] = _safe_div(completed, total_req)
+    return m
+
+
+# Numeric client.* metrics surfaced as one pytest test (= one HTML row) each.
+# (short_name, unit); the value is looked up as "client.<short_name>" in the
+# dict to_client_metrics returns. request_rate is omitted (stock emits the
+# string "inf"). This is the *display surface* of the client.* vocabulary above
+# -- it lives here, beside to_client_metrics, so every vLLM flavor (single-node,
+# distributed, disaggregated, InferenceMax) shares one definition instead of
+# each suite re-listing the rows.
+CLIENT_METRICS = [
+    ("max_concurrency", "-"),
+    ("max_concurrent_requests", "-"),
+    ("num_prompts", "-"),
+    ("completed", "-"),
+    ("failed", "-"),
+    ("success_rate", "-"),
+    ("duration", "s"),
+    ("request_throughput", "req/s"),
+    ("goodput", "req/s"),
+    ("output_throughput", "tok/s"),
+    ("total_token_throughput", "tok/s"),
+    ("per_gpu_throughput", "tok/s"),
+    ("decode_throughput_p50", "tok/s"),
+    ("max_output_tokens_per_s", "tok/s"),
+    ("total_input_tokens", "-"),
+    ("total_output_tokens", "-"),
+    ("mean_ttft_ms", "ms"),
+    ("median_ttft_ms", "ms"),
+    ("p90_ttft_ms", "ms"),
+    ("p95_ttft_ms", "ms"),
+    ("p99_ttft_ms", "ms"),
+    ("normalized_ttft_ms_per_tok", "ms/tok"),
+    ("mean_tpot_ms", "ms"),
+    ("median_tpot_ms", "ms"),
+    ("p90_tpot_ms", "ms"),
+    ("p95_tpot_ms", "ms"),
+    ("p99_tpot_ms", "ms"),
+    ("mean_itl_ms", "ms"),
+    ("median_itl_ms", "ms"),
+    ("p95_itl_ms", "ms"),
+    ("p99_itl_ms", "ms"),
+    ("decode_latency_ratio", "-"),
+    ("mean_e2el_ms", "ms"),
+    ("median_e2el_ms", "ms"),
+    ("p90_e2el_ms", "ms"),
+    ("p95_e2el_ms", "ms"),
+    ("p99_e2el_ms", "ms"),
+]
+CLIENT_METRIC_UNITS = dict(CLIENT_METRICS)
+
+# The perf+health SLO contract: the subset of CLIENT_METRICS a calibrated run
+# must *assert*, not merely display. The loader's coverage check requires a
+# threshold spec for every name here in every present cell, so a gated metric
+# can never silently fall through to a zero-assertion record-only row.
+#
+# Membership = "out of range means FAILURE", not "informational". Gated:
+# throughput (total + per-request output), the FULL latency distribution
+# (mean/median/p90/p95/p99 for ttft, tpot, itl, e2el -- itl has no p90), and run
+# health (success_rate floor, failed ceiling). Record-only by design: inputs
+# (num_prompts), totals (total_*_tokens), secondary throughputs (per_gpu_*,
+# decode_throughput_p50, max_output_tokens_per_s, request_throughput, goodput),
+# and derived diagnostics (normalized_ttft_ms_per_tok, decode_latency_ratio).
+#
+# Closed-world default: a NEW metric added to CLIENT_METRICS is record-only
+# until its name is added here. Add a metric to this set the moment it becomes
+# a pass/fail criterion -- the loader then forces a spec for it in every cell
+# before the suite can run green. Every name must also appear in CLIENT_METRICS
+# (a gated metric with no producer would gate a '-'); a unit test pins that.
+GATED_METRICS = {
+    # throughput
+    "total_token_throughput",
+    "output_throughput",
+    # latency -- full distribution per family (mean/median/p90/p95/p99;
+    # itl has no p90 producer). Every emitted quantile is a pass/fail gate.
+    "mean_ttft_ms",
+    "median_ttft_ms",
+    "p90_ttft_ms",
+    "p95_ttft_ms",
+    "p99_ttft_ms",
+    "mean_tpot_ms",
+    "median_tpot_ms",
+    "p90_tpot_ms",
+    "p95_tpot_ms",
+    "p99_tpot_ms",
+    "mean_itl_ms",
+    "median_itl_ms",
+    "p95_itl_ms",
+    "p99_itl_ms",
+    "mean_e2el_ms",
+    "median_e2el_ms",
+    "p90_e2el_ms",
+    "p95_e2el_ms",
+    "p99_e2el_ms",
+    # run health
+    "success_rate",
+    "failed",
+}
diff --git a/cvs/lib/inference/vllm_orch.py b/cvs/lib/inference/vllm_orch.py
index 63f079ba..f1d60447 100644
--- a/cvs/lib/inference/vllm_orch.py
+++ b/cvs/lib/inference/vllm_orch.py
@@ -5,7 +5,8 @@
 Standalone vLLM single-node job driven by a ContainerOrchestrator.
 
 This class talks only to `orch.exec`, which already routes into the running
-container, and to a typed `VariantConfig` (see `cvs.lib.dtni.config_loader`).
+container, and to a typed `VariantConfig` (see
+`cvs.lib.inference.utils.inferencing_config_loader`).
 It is deliberately single-node and free of the `c_phdl`/`s_phdl` + manual
 `docker exec` plumbing that `cvs.lib.inference.base.InferenceBaseJob` carries.
 
@@ -27,38 +28,18 @@
 
 from __future__ import annotations
 
+import json
+import math
 import re
 import shlex
 import time
 
 from cvs.lib import globals
+from cvs.lib.inference.utils.vllm_parsing import to_client_metrics
 
 log = globals.log
 
 
-_METRIC_RES = [
-    ("successful_requests", re.compile(r"Successful requests:\s+([0-9]+)", re.I)),
-    ("benchmark_duration", re.compile(r"Benchmark duration\s+\(s\):\s+([0-9\.]+)", re.I)),
-    ("total_input_tokens", re.compile(r"Total input tokens:\s+([0-9\.]+)", re.I)),
-    ("total_generated_tokens", re.compile(r"Total generated tokens:\s+([0-9\.]+)", re.I)),
-    ("request_throughput_per_sec", re.compile(r"Request throughput \(req/s\):\s+([0-9\.]+)", re.I)),
-    ("output_throughput_per_sec", re.compile(r"Output token throughput \(tok/s\):\s+([0-9\.]+)", re.I)),
-    ("total_throughput_per_sec", re.compile(r"Total Token throughput \(tok/s\):\s+([0-9\.]+)", re.I)),
-    ("mean_ttft_ms", re.compile(r"Mean TTFT \(ms\):\s+([0-9\.]+)", re.I)),
-    ("median_ttft_ms", re.compile(r"Median TTFT \(ms\):\s+([0-9\.]+)", re.I)),
-    ("p99_ttft_ms", re.compile(r"P99 TTFT \(ms\):\s+([0-9\.]+)", re.I)),
-    ("mean_tpot_ms", re.compile(r"Mean TPOT \(ms\):\s+([0-9\.]+)", re.I)),
-    ("median_tpot_ms", re.compile(r"Median TPOT \(ms\):\s+([0-9\.]+)", re.I)),
-    ("p99_tpot_ms", re.compile(r"P99 TPOT \(ms\):\s+([0-9\.]+)", re.I)),
-    ("mean_itl_ms", re.compile(r"Mean ITL \(ms\):\s+([0-9\.]+)", re.I)),
-    ("median_itl_ms", re.compile(r"Median ITL \(ms\):\s+([0-9\.]+)", re.I)),
-    ("p99_itl_ms", re.compile(r"P99 ITL \(ms\):\s+([0-9\.]+)", re.I)),
-    ("mean_e2el_ms", re.compile(r"Mean E2EL \(ms\):\s+([0-9\.]+)", re.I)),
-    ("median_e2el_ms", re.compile(r"Median E2EL \(ms\):\s+([0-9\.]+)", re.I)),
-    ("p99_e2el_ms", re.compile(r"P99 E2EL \(ms\):\s+([0-9\.]+)", re.I)),
-]
-
-
 class VllmJob:
     """Single-node vLLM benchmark job driven by an injected ContainerOrchestrator.
 
@@ -111,6 +92,7 @@ def __init__(
         osl,
         concurrency,
         num_prompts,
+        goodput_slo=None,
         log_subdir="vllm",
         server_precheck_wait_s=30,
         server_warmup_wait_s=330,
@@ -132,12 +114,16 @@ def __init__(
         self.osl = str(osl)
         self.concurrency = str(concurrency)
         self.num_prompts = str(num_prompts)
+        # Per-cell SLO dict {ttft_ms, tpot_ms, e2el_ms} or None. An INPUT to the
+        # run (passed to `vllm bench serve --goodput`), threaded per-cell like isl
+        # because e2el scales with osl. None -> the --goodput flag is omitted and
+        # stock leaves request_goodput null.
+        self.goodput_slo = goodput_slo
         self.log_subdir = log_subdir
 
         p = variant.params
         self.tp = p.tensor_parallelism
         self.port_no = p.port_no
-        self.max_model_length = p.max_model_length
         self.random_range_ratio = p.random_range_ratio
         self.random_prefix_len = p.random_prefix_len
         self.burstiness = p.burstiness
@@ -151,9 +137,12 @@ def __init__(
         self.backend = p.backend
 
         self.model_id = variant.model.id
-        self.server_script = variant.roles.server.server_script
         self.log_dir = variant.paths.log_dir
-        self.scripts_dir = variant.paths.benchmark_scripts_dir
+        # Per-model server quirks from config (both default empty): extra
+        # `vllm serve` flags and extra env vars merged over the orchestrator's
+        # defaults. The server command itself is Python-built (no .sh script).
+        self.serve_args = dict(variant.roles.server.serve_args)
+        self.server_env = dict(variant.roles.server.env)
         # Pin the HF cache onto the mounted models dir. The container binds
         # models_dir both at /models and (via the home bind mount) at its own
         # host path, so this path is valid inside the container and the bytes
@@ -162,9 +151,12 @@ def __init__(
         # every run. Same value the model-fetch test polls with `du`.
         self.models_dir = variant.paths.models_dir
 
-        # Single-node: one output directory.
-        self.out_dir = f"{self.log_dir}/{self.log_subdir}/out-node0"
-        self.server_log = f"{self.out_dir}/{self.server_script}_server.log"
+        # Single-node, per-cell output directory. Keyed by the cell (isl/osl/
+        # conc) so a multi-cell sweep does not overwrite an earlier cell's
+        # artifacts -- and so parse_results can never cat a stale `results` from
+        # a prior cell when the current cell's client failed to write one.
+        self.out_dir = f"{self.log_dir}/{self.log_subdir}/out-node0/isl{self.isl}_osl{self.osl}_conc{self.concurrency}"
+        self.server_log = f"{self.out_dir}/vllm_serve_server.log"
         self.client_log = f"{self.out_dir}/client.log"
 
         self._precheck_wait = server_precheck_wait_s
@@ -177,32 +169,94 @@ def __init__(
 
     # ---------- server side ----------
 
+    # vLLM's RandomDataset samples input in [isl*(1-r), isl*(1+r)] and output in
+    # [osl*(1-r), osl*(1+r)] (r = random_range_ratio), then prepends random_prefix_len
+    # fixed tokens. --max-model-len must cover the worst-case input+output+prefix or
+    # vLLM 400s every over-length request. Derive it per cell so any sweep change
+    # (isl/osl/ratio) stays self-consistent; +8 absorbs the sampler's integer rounding.
+    _MML_PAD = 8
+
+    def _derive_max_model_len(self):
+        r = float(self.random_range_ratio)
+        worst = (int(self.isl) + int(self.osl)) * (1.0 + r)
+        return str(math.ceil(worst) + int(self.random_prefix_len) + self._MML_PAD)
+
     def build_server_cmd(self):
-        """Write the server-env script and create the per-node out-dir inside the container."""
+        """Write the server-env script (sourced by both server and client)
+        and create the per-node out-dir inside the container."""
+        # Only the HF cache pin + token and the AITER tuning flags are read by
+        # the vllm process. The server and client commands are Python-built and
+        # pass every other value (model, isl/osl, tp, port, max-model-len) as an
+        # explicit flag, so exporting them here would be dead.
         env_lines = [
-            f"export MODEL={shlex.quote(self.model_id)}",
-            f"export ISL={shlex.quote(self.isl)}",
-            f"export OSL={shlex.quote(self.osl)}",
-            f"export MAX_MODEL_LEN={shlex.quote(self.max_model_length)}",
-            f"export RANDOM_RANGE_RATIO={shlex.quote(self.random_range_ratio)}",
-            f"export TP={shlex.quote(str(self.tp))}",
-            f"export CONC={shlex.quote(self.concurrency)}",
             f"export HF_TOKEN={shlex.quote(self.hf_token)}",
             f"export HF_HUB_CACHE={shlex.quote(self.models_dir)}",
             "export VLLM_USE_AITER_UNIFIED_ATTENTION=1",
             "export VLLM_ROCM_USE_AITER_MHA=0",
             "export VLLM_ROCM_USE_AITER_FUSED_MOE_A16W4=1",
-            f"export PORT={shlex.quote(str(self.port_no))}",
         ]
+        # Per-model env overrides win over the defaults above (appended last).
+        for k, v in self.server_env.items():
+            env_lines.append(f"export {k}={shlex.quote(str(v))}")
         env_script = "\n".join(env_lines) + "\n"
         # printf the script body verbatim; shlex.quote protects the outer bash layer.
         self.orch.exec("bash -c " + shlex.quote(f"printf '%s' {shlex.quote(env_script)} > /tmp/server_env_script.sh"))
         self.orch.exec(f"mkdir -p {shlex.quote(self.out_dir)}")
 
+    @staticmethod
+    def _flatten_serve_args(mapping):
+        """A {flag: value} serve-args map -> a flat `vllm serve` arg list.
+
+        Flags are given without the leading `--`. A scalar renders
+        `--flag <value>`; True renders a bare `--flag` (e.g. --trust-remote-code);
+        a list renders the flag once per element (a repeatable flag). This keeps
+        config readable ({"kv-cache-dtype": "fp8"}) while still covering vllm's
+        bare and repeatable flags, which a flat list could express but not read.
+        """
+        argv = []
+        for flag, value in mapping.items():
+            opt = f"--{flag}"
+            if value is True:
+                argv.append(opt)
+            elif isinstance(value, (list, tuple)):
+                for v in value:
+                    argv.extend([opt, str(v)])
+            else:
+                argv.extend([opt, str(value)])
+        return argv
+
+    def _server_argv(self):
+        """The `vllm serve` arg list for this cell.
+
+        Built in Python (mirrors run_client) so a run is self-contained -- no
+        external `.sh` to clone/stage. Only the derived, framework-generic flags
+        (tp/max-model-len/port, computed per cell) are set here; per-model knobs
+        (e.g. --kv-cache-dtype for an FP8-KV model) come from roles.server.serve_args
+        so this driver stays model-agnostic.
+        """
+        argv = [
+            "vllm",
+            "serve",
+            self.model_id,
+            "--tensor-parallel-size",
+            str(self.tp),
+            "--max-model-len",
+            self._derive_max_model_len(),
+            "--port",
+            str(self.port_no),
+        ]
+        argv.extend(self._flatten_serve_args(self.serve_args))
+        return argv
+
     def start_server(self):
+        # Each token shlex.quoted: a model id/path with a space or $ would
+        # otherwise break the inner bash layer silently (same quoting as the
+        # client). The env script (HF token, AITER flags, cache pin) is sourced
+        # first; nohup backgrounds the server into its fixed log.
+        serve_cmd = " ".join(shlex.quote(str(a)) for a in self._server_argv())
         inner = (
-            f"cd {shlex.quote(self.scripts_dir)} && source /tmp/server_env_script.sh && "
-            f"nohup /bin/bash {shlex.quote(self.server_script)} > {shlex.quote(self.server_log)} 2>&1 &"
+            f"source /tmp/server_env_script.sh && "
+            f"nohup {serve_cmd} > {shlex.quote(self.server_log)} 2>&1 &"
         )
         out = self.orch.exec("bash -c " + shlex.quote(inner))
         for host, output in out.items():
@@ -286,6 +340,8 @@ def run_client(self):
             self.random_prefix_len,
             "--percentile-metrics",
             self.percentile_metrics,
+            "--metric-percentiles",
+            self.metric_percentiles,
             "--ignore-eos",
             "--save-result",
             "--result-dir",
@@ -293,6 +349,16 @@ def run_client(self):
             "--result-filename",
             "results",
         ]
+        # Goodput SLO gate (optional). Stock computes request_goodput (good-req/s)
+        # only when --goodput is passed; a request is good iff it meets EVERY named
+        # SLO. Omit the flag entirely when no per-cell SLO is set (passing
+        # ttft:None would be a launch failure).
+        if self.goodput_slo:
+            args.append("--goodput")
+            for metric, key in (("ttft", "ttft_ms"), ("tpot", "tpot_ms"), ("e2el", "e2el_ms")):
+                val = self.goodput_slo.get(key)
+                if val is not None:
+                    args.append(f"{metric}:{val}")
         bench_cmd = " ".join(shlex.quote(str(a)) for a in args)
         client_cmd = f"source /tmp/server_env_script.sh && {bench_cmd} > {shlex.quote(self.client_log)} 2>&1 &"
         self.orch.exec("bash -c " + shlex.quote(client_cmd))
@@ -325,15 +391,27 @@ def wait_client_complete(self):
         raise RuntimeError("client did not complete before poll cap")
 
     def parse_results(self):
-        """Return {host: {metric: str_value}} parsed from the client log."""
-        out = self.orch.exec(f"tail -2000 {shlex.quote(self.client_log)}")
+        """Return {host: {client.METRIC: value}} parsed from the stock `results` artifact.
+
+        Fetches the extensionless JSON `results` file `vllm bench serve` writes to
+        `--result-dir` (NOT the console log; NOT `results.json`) and delegates the
+        namespacing + derived-metric math to the pure
+        `cvs.lib.inference.utils.vllm_parsing.to_client_metrics`. Raises if the artifact is
+        missing/empty/unparseable -- the test wraps the job in try/except ... raise,
+        so this hard-fails the cell rather than recording an empty (silently-green)
+        row. The fetch lives here because artifact layout is job-specific; the
+        transform lives in inference.utils so distributed/disagg/InferenceMax can reuse it.
+        """
+        artifact = f"{self.out_dir}/results"
+        out = self.orch.exec(f"cat {shlex.quote(artifact)}")
         results = {}
         for host, text in out.items():
-            text = text or ""
-            m = {}
-            for key, pat in _METRIC_RES:
-                hit = pat.search(text)
-                if hit:
-                    m[key] = hit.group(1)
-            results[host] = m
+            text = (text or "").strip()
+            if not text:
+                raise RuntimeError(f"empty/missing results artifact on {host}: {artifact}")
+            try:
+                raw = json.loads(text)
+            except (json.JSONDecodeError, ValueError) as e:
+                raise RuntimeError(f"unparseable results artifact on {host}: {artifact}: {e}") from e
+            results[host] = to_client_metrics(raw, tp=self.tp, isl=self.isl)
         return results
diff --git a/cvs/lib/inference_lib.py b/cvs/lib/inference_lib.py
index 9a8813df..65532e14 100644
--- a/cvs/lib/inference_lib.py
+++ b/cvs/lib/inference_lib.py
@@ -6,18 +6,39 @@
 '''
 
 from cvs.lib import globals
-from cvs.lib.inference_max_lib import InferenceMaxJob, VllmJob
 
 log = globals.log
 
 
+class _LegacyVllmInferenceJobPlaceholder:
+    """``InferenceJobFactory`` no longer constructs a host+docker vLLM ``InferenceBaseJob``."""
+
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError(
+            "InferenceJobFactory no longer builds a host+docker vLLM InferenceBaseJob. "
+            "Use ``cvs.lib.inference.vllm_orch.VllmJob`` with ``ContainerOrchestrator`` "
+            "from the tests under ``cvs.tests.inference.vllm``."
+        )
+
+
+class _LegacyInferenceMaxInferenceJobPlaceholder:
+    """``InferenceJobFactory`` no longer constructs a host+docker InferenceMax ``InferenceBaseJob``."""
+
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError(
+            "InferenceJobFactory no longer builds a host+docker InferenceMax InferenceBaseJob. "
+            "Use ``cvs.lib.inference.inferencemax_orch.InferenceMaxJob`` with "
+            "``ContainerOrchestrator`` from the tests under ``cvs.tests.inference.inferencemax``."
+        )
+
+
 class InferenceJobFactory:
     """Factory class to create inference job instances based on framework type."""
 
     # Registry of supported frameworks
     _FRAMEWORK_CLASSES = {
-        'vllm': VllmJob,
-        'inferencemax': InferenceMaxJob,
+        'vllm': _LegacyVllmInferenceJobPlaceholder,
+        'inferencemax': _LegacyInferenceMaxInferenceJobPlaceholder,
     }
 
     @classmethod
@@ -72,7 +93,8 @@ def create_job(
             framework: Framework type ('vllm', 'inferencemax', or None for auto-detect)
 
         Returns:
-            Instance of VllmJob or InferenceMaxJob
+            Instance of :class:`~cvs.lib.inference.inferencemax_orch.InferenceMaxJob` or the
+            vLLM placeholder (raises if selected).
 
         Raises:
             ValueError: If framework is not supported
diff --git a/cvs/lib/sglang_disagg_lib.py b/cvs/lib/sglang_disagg_lib.py
index bf41e239..4e6d0985 100644
--- a/cvs/lib/sglang_disagg_lib.py
+++ b/cvs/lib/sglang_disagg_lib.py
@@ -959,7 +959,7 @@ def get_inference_results_dict(self, out_dict):
                 self.inference_results_dict[node]['total_input_tokens'] = match.group(1)
             if re.search('Total generated tokens:', out_dict[node], re.I):
                 match = re.search('Total generated tokens:\s+([0-9\.]+)', out_dict[node], re.I)
-                self.inference_results_dict[node]['Total generated tokens:'] = match.group(1)
+                self.inference_results_dict[node]['total_generated_tokens'] = match.group(1)
             if re.search('Request throughput \(req/s\):', out_dict[node], re.I):
                 match = re.search('Request throughput \(req/s\):\s+([0-9\.]+)', out_dict[node], re.I)
                 self.inference_results_dict[node]['request_throughput_per_sec'] = match.group(1)
diff --git a/cvs/lib/utils/AGENTS.md b/cvs/lib/utils/AGENTS.md
new file mode 100644
index 00000000..8217128f
--- /dev/null
+++ b/cvs/lib/utils/AGENTS.md
@@ -0,0 +1,76 @@
+# cvs/lib/utils — shared, framework-agnostic config machinery
+
+Pure functions and schema any CVS suite (inference, training, …) can call. No
+suite-specific knowledge lives here. If something only an inference suite needs
+crept in, it belongs in `cvs/lib/inference/utils/` instead — keep this boundary.
+
+## What's here
+
+- `config_loader.py` — the generic half of variant-config loading: the
+  `paths`/`model`/`container` schema, `BaseVariantConfig`, the 3-pass
+  placeholder substitution engine, and `substitute_config()`.
+- `verdict.py` — `evaluate_all(actuals, thresholds)`: a tiny, framework-neutral
+  threshold checker.
+
+## Public entry points
+
+- `substitute_config(config_path, cluster_dict) -> (raw_dict, thresholds)`
+  Reads a variant `*_config.json` + its sibling `*threshold.json`, resolves all
+  placeholders, strips threshold comment keys. Returns the substituted-but-
+  **unvalidated** dict plus the parsed thresholds. A per-framework loader calls
+  this, then builds its own typed `VariantConfig(**raw)`.
+- `BaseVariantConfig` — subclass it per framework. Carries the shared fields
+  (`schema_version`, `enforce_thresholds`, `paths`, `model`, `container`,
+  `thresholds`) and the `model.remote==1` NotImplementedError guard. The image
+  is declared once on `container.image` — there is no separate top-level block.
+- `evaluate_all(actuals, thresholds)` — raises `ThresholdViolation` listing every
+  failing metric. Threshold kinds: `min`, `max` (unit-agnostic ceiling, for
+  counts like `failed`), `max_ms` (a ceiling that prints `ms`), `within`
+  (±tolerance_pct), `min_tok_s`, `min_ratio` (compares against another metric
+  named in `reference`).
+
+## The seam (why this is split out)
+
+`config_loader.py` used to be one monolith mixing generic machinery with
+inference-only schema (`Sweep`/`SeqCombo`/`cell_key`). The generic half stayed
+here; the inference half moved to
+`cvs.lib.inference.utils.inferencing_config_loader`, which imports
+`BaseVariantConfig`, `_Forbid`, and `substitute_config` from here. A second
+framework (training) does the same: subclass `BaseVariantConfig`, reuse
+`substitute_config` and `evaluate_all`, add its own schema in its own dir.
+
+## Gotchas worth not re-discovering
+
+- **Placeholder resolution is 3 ordered passes** (`substitute_config`):
+  (1) cluster placeholders like `{user-id}` everywhere, (2) self-reference within
+  the `paths` block (`{shared_fs}` → expanded inside other `paths.*`),
+  (3) cross-block `{paths.models_dir}` → anywhere. An unknown `{token}` is left
+  **verbatim**, not errored — a typo'd placeholder surfaces as a literal brace in
+  a path, not a load failure.
+- **Threshold file is found by sibling glob**, not by name: exactly one
+  `*threshold.json` next to the config. Zero → `FileNotFoundError`; more than one
+  → `ValueError` (ambiguous). So config and threshold can share a descriptive
+  prefix (`llama31_70b_fp8_config.json` / `…_threshold.json`) but don't have to.
+- **Threshold comment keys** (anything starting with `_`, e.g. `_comment`) are
+  stripped before the coverage check, so you can document a threshold file inline.
+- **`_Forbid` vs `_Allow`**: most schema classes forbid extra keys (a typo fails
+  load loudly). `RuntimeSpec` is `_Allow` (orchestrator runtime args are
+  open-ended). Don't loosen `_Forbid` to silence a "valid" key — add the field.
+- **`BaseVariantConfig` validators run parent-first.** The remote-not-implemented
+  check is intentionally first so a remote config fails fast before any
+  subclass's (meaningless-for-a-rejected-config) coverage check runs. If you add
+  a base validator, mind the ordering contract.
+- **`container.model_dump()` is the orchestrator contract.** The loaded
+  `container` field serialises to the exact `{lifetime, name, image, runtime:
+  {name, args}}` shape `OrchestratorConfig.from_configs` consumes. Don't reshape
+  it here.
+- `model.remote==1` raises `NotImplementedError` (remote model download is
+  unported PoC scope). The schema accepts it; the validator rejects it.
+
+## When extending
+
+- New generic threshold kind → add a branch in `verdict._check_one` and document
+  it above. Keep it metric-name-agnostic.
+- New shared config field every suite needs → add to `BaseVariantConfig`.
+- Anything inference/training-specific → NOT here. See the sibling
+  `cvs/lib/inference/utils/AGENTS.md`.
diff --git a/cvs/lib/utils/__init__.py b/cvs/lib/utils/__init__.py
new file mode 100644
index 00000000..d3438a6e
--- /dev/null
+++ b/cvs/lib/utils/__init__.py
@@ -0,0 +1,4 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+'''
diff --git a/cvs/lib/utils/config_loader.py b/cvs/lib/utils/config_loader.py
new file mode 100644
index 00000000..86ab589e
--- /dev/null
+++ b/cvs/lib/utils/config_loader.py
@@ -0,0 +1,213 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+
+Framework-agnostic config machinery shared by every CVS suite.
+
+Holds the generic half of what used to be one monolithic loader: the
+container/paths/model/image schema, the 3-pass placeholder substitution, the
+`enforce_thresholds` gate carried on `BaseVariantConfig`, and the
+`substitute_config` helper that reads a variant `config.json` + sibling
+`*threshold.json` and resolves placeholders. A per-framework module subclasses
+`BaseVariantConfig` and adds its own `Params`/`Sweep`/`cell_key` (see
+`cvs.lib.inference.utils.inferencing_config_loader` for the vllm flavour).
+
+3-pass placeholder substitution:
+  1. cluster placeholders (`{user-id}`) anywhere
+  2. self-reference within `paths` (e.g. `{shared_fs}`)
+  3. cross-block (`{paths.models_dir}`, etc.) into the rest of the doc
+
+A loaded variant's `container` field (`lifetime`, `name`, `image`, `runtime`)
+matches the dict shape that `cvs.core.orchestrators.factory.OrchestratorConfig`
+already understands. `runtime` is a nested `RuntimeSpec`, not a flat dict;
+`container.model_dump()` serialises it to the `runtime: {name, args}` shape the
+factory consumes (the vllm conftest does exactly this before building the
+orchestrator). The loaded variant also carries a `thresholds` field with the
+parsed threshold contents.
+
+`model.remote=1` raises NotImplementedError -- schema is present, but the
+download/resolve logic lives in cvs-dtni-v1's `resource_resolver.py` and is
+out of scope for this PoC.
+'''
+
+from __future__ import annotations
+
+import getpass
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing_extensions import Literal
+
+
+# ---------- pydantic models (generic) ----------
+
+
+class _Forbid(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class _Allow(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
+class Paths(_Forbid):
+    shared_fs: str
+    models_dir: str
+    log_dir: str
+    hf_token_file: str
+
+
+class ModelSpec(_Forbid):
+    id: str
+    remote: Literal[0, 1]
+    precision: str
+
+
+class RuntimeSpec(_Allow):
+    name: str
+    args: Dict[str, Any] = Field(default_factory=dict)
+
+
+class ContainerSpec(_Forbid):
+    lifetime: Literal["no_launch", "per_run", "persistent"] = "per_run"
+    name: str
+    image: str
+    runtime: RuntimeSpec
+
+
+class BaseVariantConfig(_Forbid):
+    """The framework-agnostic skeleton of a variant config.
+
+    Carries the fields every suite shares (schema/paths/model/image/container/
+    thresholds + the enforce gate) and the remote-not-implemented guard.
+    Per-framework subclasses add their own `framework`/`Params`/`Sweep` and the
+    `cell_key`/coverage-check pair that depend on them.
+    """
+
+    schema_version: Literal[1]
+    # When false, the threshold-coverage gate warns instead of raising and the
+    # test records metrics without asserting pass/fail (record-only). Use for
+    # un-calibrated shapes (e.g. a throughput characterization whose published
+    # numbers are curves, not tabulated values). Default true keeps the gate
+    # strict for calibrated configs -- no regression to the remediation work.
+    enforce_thresholds: bool = True
+    paths: Paths
+    model: ModelSpec
+    # The container image is declared once, on container.image (ContainerSpec).
+    # There is no separate top-level image block.
+    container: ContainerSpec
+    thresholds: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
+
+    # pydantic runs @model_validator(mode="after") hooks in definition order,
+    # parent-class hooks before subclass hooks. This remote check is intentionally
+    # the first to run: an unimplemented remote config fails fast
+    # (NotImplementedError) before any subclass's threshold-coverage check runs,
+    # which is meaningless for a config we are going to reject anyway.
+    @model_validator(mode="after")
+    def _check_remote_not_implemented(self):
+        if self.model.remote == 1:
+            raise NotImplementedError(
+                "model.remote=1 (remote model download) is not implemented in the PoC. "
+                "Port from cvs-dtni-v1/resource_resolver.py before enabling."
+            )
+        return self
+
+
+# ---------- placeholder substitution ----------
+
+_PLACEHOLDER_RE = re.compile(r"\{([a-zA-Z0-9_.\-]+)\}")
+
+
+def _walk_substitute(node, mapping):
+    if isinstance(node, str):
+
+        def repl(m):
+            key = m.group(1)
+            if key in mapping:
+                return str(mapping[key])
+            return m.group(0)
+
+        return _PLACEHOLDER_RE.sub(repl, node)
+    if isinstance(node, list):
+        return [_walk_substitute(x, mapping) for x in node]
+    if isinstance(node, dict):
+        return {k: _walk_substitute(v, mapping) for k, v in node.items()}
+    return node
+
+
+def _flatten_paths(d, prefix=""):
+    out = {}
+    for k, v in d.items():
+        key = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            out.update(_flatten_paths(v, key))
+        elif isinstance(v, (str, int, float)):
+            out[key] = str(v)
+    return out
+
+
+def _resolve_cluster_mapping(cluster_dict):
+    raw = cluster_dict.get("username") or "{user-id}"
+    user = getpass.getuser() if raw == "{user-id}" else raw
+    return {"user-id": user}
+
+
+# ---------- public API (generic) ----------
+
+
+def substitute_config(config_path, cluster_dict):
+    """Read a variant config + sibling threshold file and resolve placeholders.
+
+    Returns `(raw_dict, thresholds)`: the substituted config dict (NOT yet
+    validated -- the caller's per-framework `VariantConfig(**raw)` does that)
+    and the parsed, comment-stripped threshold dict. The threshold file is the
+    sole `*threshold.json` next to the config (e.g. `..._threshold.json` beside
+    `..._config.json`), so config and threshold can share a descriptive
+    per-variant prefix.
+
+    This is the framework-neutral body of the old `load_variant`: file read +
+    3-pass substitution + sibling-threshold discovery/strip. Per-framework
+    loaders call it, attach `thresholds`, then build their typed config.
+    """
+    config_path = Path(config_path)
+    if not config_path.is_file():
+        raise FileNotFoundError(f"variant config not found: {config_path}")
+
+    raw = json.loads(config_path.read_text())
+
+    threshold_candidates = sorted(config_path.parent.glob("*threshold.json"))
+    if not threshold_candidates:
+        raise FileNotFoundError(f"no *threshold.json next to config: {config_path.parent}")
+    if len(threshold_candidates) > 1:
+        raise ValueError(f"multiple *threshold.json files next to config (ambiguous): {threshold_candidates}")
+    threshold_path = threshold_candidates[0]
+    thresholds = json.loads(threshold_path.read_text())
+
+    # Pass 1: cluster placeholders ({user-id}) everywhere.
+    cluster_map = _resolve_cluster_mapping(cluster_dict)
+    raw = _walk_substitute(raw, cluster_map)
+
+    # Pass 2: self-reference within paths ({shared_fs} inside paths.*).
+    paths_block = raw.get("paths", {})
+    if isinstance(paths_block, dict):
+        for _ in range(len(paths_block) + 1):
+            new = {
+                k: _walk_substitute(v, {pk: pv for pk, pv in paths_block.items() if isinstance(pv, str)})
+                for k, v in paths_block.items()
+            }
+            if new == paths_block:
+                break
+            paths_block = new
+        raw["paths"] = paths_block
+
+    # Pass 3: cross-block ({paths.models_dir} -> anywhere else).
+    flat_map = _flatten_paths({"paths": raw.get("paths", {})})
+    raw = _walk_substitute(raw, flat_map)
+
+    # Drop threshold-file comment keys (e.g. "_comment") before coverage check.
+    thresholds = {k: v for k, v in thresholds.items() if not k.startswith("_")}
+
+    return raw, thresholds
diff --git a/cvs/lib/dtni/verdict.py b/cvs/lib/utils/verdict.py
similarity index 75%
rename from cvs/lib/dtni/verdict.py
rename to cvs/lib/utils/verdict.py
index 467f4432..3f421e17 100644
--- a/cvs/lib/dtni/verdict.py
+++ b/cvs/lib/utils/verdict.py
@@ -27,6 +27,12 @@ def _check_one(metric, actual_raw, spec):
         target = _to_float(spec["value"])
         if actual > target:
             return f"{metric}: actual {actual} ms > max {target} ms"
+    elif kind == "max":
+        # Unit-agnostic upper bound, for counts like `failed` where `max_ms`
+        # would be a unit lie. Same comparison, honest message.
+        target = _to_float(spec["value"])
+        if actual > target:
+            return f"{metric}: actual {actual} > max {target}"
     elif kind == "within":
         target = _to_float(spec["value"])
         pct = _to_float(spec["tolerance_pct"])
@@ -43,6 +49,8 @@ def _check_one(metric, actual_raw, spec):
         actuals = spec.get("_actuals", {})
         if ref_metric not in actuals:
             return f"{metric}: reference metric '{ref_metric}' missing from actuals"
+        if actuals[ref_metric] is None:
+            return f"{metric}: reference '{ref_metric}' is None (metric unavailable for this run)"
         ref_actual = _to_float(actuals[ref_metric])
         if ref_actual == 0:
             return f"{metric}: reference '{ref_metric}' is 0; cannot compute ratio"
@@ -60,6 +68,12 @@ def evaluate_all(actuals, thresholds):
         if metric not in actuals:
             violations.append(f"{metric}: missing from actuals")
             continue
+        if actuals[metric] is None:
+            # A derived/goodput metric that could not be computed (e.g.
+            # decode_latency_ratio with no p50, or goodput with no SLO run).
+            # Loud violation, not a float(None) TypeError.
+            violations.append(f"{metric}: value is None (metric unavailable for this run)")
+            continue
         spec_with_actuals = dict(spec)
         if spec.get("kind") == "min_ratio":
             spec_with_actuals["_actuals"] = actuals
diff --git a/cvs/tests/inference/inferencemax/_shared.py b/cvs/tests/inference/inferencemax/_shared.py
new file mode 100644
index 00000000..b9f50723
--- /dev/null
+++ b/cvs/tests/inference/inferencemax/_shared.py
@@ -0,0 +1,58 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+'''
+
+from tabulate import tabulate
+
+from cvs.lib import globals
+
+log = globals.log
+
+__all__ = ["test_print_results_table"]
+
+
+def _cell(m, key):
+    v = m.get(key)
+    return "-" if v is None else v
+
+
+def test_print_results_table(inf_res_dict):
+    if not inf_res_dict:
+        log.info("inf_res_dict empty, nothing to print")
+        return
+    headers = [
+        "Model",
+        "GPU",
+        "ISL",
+        "OSL",
+        "Policy",
+        "Conc",
+        "Host",
+        "Output tok/s",
+        "Total tok/s",
+        "Mean TTFT (ms)",
+        "Mean TPOT (ms)",
+        "P99 ITL (ms)",
+    ]
+    rows = []
+    for key, host_dict in inf_res_dict.items():
+        model, gpu, isl, osl, policy, conc = key
+        for host, m in host_dict.items():
+            rows.append(
+                [
+                    model,
+                    gpu,
+                    isl,
+                    osl,
+                    policy,
+                    conc,
+                    host,
+                    _cell(m, "client.output_throughput"),
+                    _cell(m, "client.total_token_throughput"),
+                    _cell(m, "client.mean_ttft_ms"),
+                    _cell(m, "client.mean_tpot_ms"),
+                    _cell(m, "client.p99_itl_ms"),
+                ]
+            )
+    log.info("\n" + tabulate(rows, headers=headers, tablefmt="github"))
diff --git a/cvs/tests/inference/inferencemax/conftest.py b/cvs/tests/inference/inferencemax/conftest.py
new file mode 100644
index 00000000..07d41e14
--- /dev/null
+++ b/cvs/tests/inference/inferencemax/conftest.py
@@ -0,0 +1,153 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+'''
+
+import json
+import os
+
+import pytest
+
+from cvs.core.orchestrators.factory import OrchestratorConfig, OrchestratorFactory
+from cvs.lib import globals
+from cvs.lib.inference.utils.inferencemax_config_loader import (
+    load_variant,
+    orchestrator_container_from_variant,
+)
+from cvs.lib.utils_lib import resolve_cluster_config_placeholders
+
+log = globals.log
+
+
+def _deep_merge(base, override):
+    """Recursively merge `override` onto `base` (dicts merged key-wise, scalars/lists replaced)."""
+    if not (isinstance(base, dict) and isinstance(override, dict)):
+        return override
+    out = dict(base)
+    for k, v in override.items():
+        out[k] = _deep_merge(base[k], v) if k in base else v
+    return out
+
+
+class _Lifecycle:
+    def __init__(self):
+        self.failed = False
+        self.torn_down = False
+        self.report = {}
+
+    def record(self, nodeid, label, value, unit="s"):
+        self.report.setdefault(nodeid, []).append((label, value, unit))
+
+
+@pytest.fixture(scope="module")
+def cluster_dict(pytestconfig):
+    cluster_file = pytestconfig.getoption("cluster_file")
+    if not cluster_file:
+        pytest.fail("--cluster_file is required")
+    with open(cluster_file) as fp:
+        d = json.load(fp)
+    return resolve_cluster_config_placeholders(d)
+
+
+@pytest.fixture(scope="module")
+def variant_config(pytestconfig, cluster_dict):
+    config_file = pytestconfig.getoption("config_file")
+    if not config_file:
+        pytest.fail("--config_file is required")
+    return load_variant(config_file, cluster_dict)
+
+
+@pytest.fixture(scope="module")
+def lifecycle():
+    return _Lifecycle()
+
+
+@pytest.fixture(scope="module")
+def orch(cluster_dict, variant_config, lifecycle):
+    container_block = _deep_merge(
+        cluster_dict.get("container", {}),
+        orchestrator_container_from_variant(variant_config),
+    )
+    testsuite_config = {
+        "orchestrator": "container",
+        "container": container_block,
+    }
+    cfg = OrchestratorConfig.from_configs(cluster_dict, testsuite_config)
+    o = OrchestratorFactory.create_orchestrator(log, cfg)
+    yield o
+    if not lifecycle.torn_down:
+        log.info("orch fixture leak-guard: tearing down InferenceMax containers")
+        o.teardown_containers()
+
+
+@pytest.fixture(scope="module")
+def hf_token(variant_config):
+    path = variant_config.paths.hf_token_file
+    if not os.path.isfile(path):
+        pytest.skip(f"hf_token file missing: {path}")
+    with open(path) as fp:
+        return fp.read().strip()
+
+
+@pytest.fixture(scope="session")
+def inf_res_dict():
+    return {}
+
+
+def pytest_collection_modifyitems(items):
+    rank = {
+        "test_launch_container": 0,
+        "test_setup_sshd": 1,
+        "test_model_fetch": 2,
+        "test_inferencemax_inference": 3,
+        "test_metric": 4,
+        "test_print_results_table": 5,
+        "test_teardown": 6,
+    }
+    items.sort(key=lambda it: rank.get(it.originalname or it.name.split("[")[0], 99))
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+    outcome = yield
+    report = outcome.get_result()
+    if report.when != "call":
+        return
+    lc = item.funcargs.get("lifecycle")
+    rows = getattr(lc, "report", {}).get(item.nodeid) if lc else None
+    if not rows:
+        return
+    try:
+        import pytest_html
+    except ImportError:
+        return
+    body = "".join(
+        f"<tr><td>{label}</td><td>{value:.1f}</td><td>{unit}</td></tr>"
+        for label, value, unit in rows
+    )
+    html = f"<table><tr><th>stage</th><th>value</th><th>unit</th></tr>{body}</table>"
+    extras = getattr(report, "extras", [])
+    extras.append(pytest_html.extras.html(html))
+    report.extras = extras
+
+
+def pytest_html_results_table_header(cells):
+    cells.insert(-1, "<th>Value</th>")
+    cells.insert(-1, "<th>Unit</th>")
+
+
+def pytest_html_results_table_row(report, cells):
+    props = dict(report.user_properties)
+    has = "metric_value" in props
+    val = props.get("metric_value")
+    unit = props.get("metric_unit", "") if has else ""
+    if not has:
+        shown = ""
+    elif val is None:
+        shown = "-"
+    elif isinstance(val, float):
+        shown = f"{val:.3f}"
+    else:
+        shown = str(val)
+    cells.insert(-1, f"<td>{shown}</td>")
+    cells.insert(-1, f"<td>{unit}</td>")
diff --git a/cvs/tests/inference/inferencemax/inferencemax_gpt_oss_120b_single.py b/cvs/tests/inference/inferencemax/inferencemax_gpt_oss_120b_single.py
deleted file mode 100644
index a922b1a4..00000000
--- a/cvs/tests/inference/inferencemax/inferencemax_gpt_oss_120b_single.py
+++ /dev/null
@@ -1,294 +0,0 @@
-'''
-Copyright 2025 Advanced Micro Devices, Inc.
-All rights reserved. This notice is intended as a precaution against inadvertent publication and does not imply publication or any waiver of confidentiality.
-The year included in the foregoing notice is the year of creation of the work.
-All code contained here is Property of Advanced Micro Devices, Inc.
-'''
-
-import pytest
-
-import re
-import time
-import json
-
-from cvs.lib.parallel_ssh_lib import *
-from cvs.lib.utils_lib import *
-from cvs.lib import docker_lib
-from cvs.lib.inference.inference_max import InferenceMaxJob
-from cvs.lib import globals
-
-log = globals.log
-
-
-# Importing additional cmd line args to script ..
-@pytest.fixture(scope="module")
-def cluster_file(pytestconfig):
-    """
-    Retrieve the --cluster_file CLI option provided to pytest.
-
-    Args:
-      pytestconfig: Built-in pytest fixture exposing command-line options.
-
-    Returns:
-      str: Path to the cluster JSON file specified via --cluster_file.
-
-    Notes:
-      - Ensure your pytest.ini or CLI includes: --cluster_file=/path/to/cluster.json
-      - Use module scope so the value is resolved once per test module.
-    """
-    return pytestconfig.getoption("cluster_file")
-
-
-@pytest.fixture(scope="module")
-def training_config_file(pytestconfig):
-    """
-    Retrieve the --config_file CLI option provided to pytest.
-
-    Args:
-      pytestconfig: Built-in pytest fixture exposing command-line options.
-
-    Returns:
-      str: Path to the training config JSON file specified via --config_file.
-
-    Notes:
-      - Ensure your pytest.ini or CLI includes: --config_file=/path/to/training_config.json
-      - Module scope avoids re-fetching the option across tests in this module.
-    """
-    return pytestconfig.getoption("config_file")
-
-
-# Importing the cluster and cofig files to script to access node, switch, test config params
-@pytest.fixture(scope="module")
-def cluster_dict(cluster_file):
-    """
-    Load the entire cluster configuration from the provided JSON file.
-
-    Args:
-      cluster_file (str): Path to the cluster JSON file.
-
-    Returns:
-      dict: Parsed JSON representing the cluster (nodes, credentials, etc.).
-
-    Notes:
-      - Logs the loaded structure for visibility; consider using log.debug if verbose.
-    """
-    with open(cluster_file) as json_file:
-        cluster_dict = json.load(json_file)
-
-    # Resolve path placeholders like {user-id} in cluster config
-    cluster_dict = resolve_cluster_config_placeholders(cluster_dict)
-    log.info("%s", cluster_dict)
-    return cluster_dict
-
-
-@pytest.fixture(scope="module")
-def inference_dict(training_config_file, cluster_dict):
-    with open(training_config_file) as json_file:
-        inference_dict_t = json.load(json_file)
-    inference_dict = inference_dict_t['config']
-
-    # Resolve path placeholders like {user-id}, {home-mount-dir}, etc.
-    inference_dict = resolve_test_config_placeholders(inference_dict, cluster_dict)
-    return inference_dict
-
-
-@pytest.fixture(scope="module")
-def benchmark_params_dict(training_config_file, cluster_dict):
-    with open(training_config_file) as json_file:
-        inference_dict_t = json.load(json_file)
-    benchmark_params_dict = inference_dict_t['benchmark_params']
-
-    # Resolve path placeholders like {user-id}, {home-mount-dir}, etc.
-    benchmark_params_dict = resolve_test_config_placeholders(benchmark_params_dict, cluster_dict)
-
-    log.info("%s", benchmark_params_dict)
-    return benchmark_params_dict
-
-
-@pytest.fixture(scope="module")
-def hf_token(inference_dict):
-    """
-    Load the Hugging Face access token from the file path specified in the training config.
-
-    Args:
-      inference_dict (dict): Training configuration dict that includes:
-        - 'hf_token_file': Path to the file containing the HF token.
-
-    Returns:
-      str: The HF token string read from the file.
-
-    Behavior:
-      - Reads the token from inference_dict['hf_token_file'] (already resolved for placeholders).
-      - Strips the trailing newline from the token.
-    """
-    hf_token_file = inference_dict['hf_token_file']
-    try:
-        with open(hf_token_file, 'r') as fp:
-            hf_token = fp.read().rstrip("\n")
-    except FileNotFoundError:
-        log.error(f"Error: The file '{hf_token_file}' was not found.")
-    except Exception as e:
-        log.error(f"An error occurred: {e}")
-    return hf_token
-
-
-@pytest.fixture(scope="module")
-def s_phdl(cluster_dict):
-    """
-    Create and return a parallel SSH handle for all cluster nodes.
-
-    Args:
-      cluster_dict (dict): Cluster configuration loaded by another fixture. Expected keys:
-        - 'node_dict': dict of node_name -> node_details (used to derive the node list)
-        - 'username': SSH username for connecting to nodes
-        - 'priv_key_file': path to the SSH private key file
-
-    Returns:
-      Pssh: An initialized Pssh handle for issuing commands across all nodes.
-
-    Behavior:
-      - Prints the full cluster_dict for quick debugging (consider switching to log.debug to reduce noise).
-      - Collects all node names from cluster_dict['node_dict'] and constructs a Pssh handle.
-
-    Notes:
-      - This fixture has module scope, so a single connection handle is reused for all tests in the module.
-    """
-    log.info("%s", cluster_dict)
-    env_vars = cluster_dict.get("env_vars")
-    node_list = list(cluster_dict['node_dict'].keys())
-    s_phdl = Pssh(log, node_list, user=cluster_dict['username'], pkey=cluster_dict['priv_key_file'], env_vars=env_vars)
-    return s_phdl
-
-
-@pytest.fixture(scope="module")
-def c_phdl(cluster_dict):
-    """
-    Create and return a parallel SSH handle for all cluster nodes.
-
-    Args:
-      cluster_dict (dict): Cluster configuration loaded by another fixture. Expected keys:
-        - 'node_dict': dict of node_name -> node_details (used to derive the node list)
-        - 'username': SSH username for connecting to nodes
-        - 'priv_key_file': path to the SSH private key file
-
-    Returns:
-      Pssh: An initialized Pssh handle for issuing commands across all nodes.
-
-    Behavior:
-      - Prints the full cluster_dict for quick debugging (consider switching to log.debug to reduce noise).
-      - Collects all node names from cluster_dict['node_dict'] and constructs a Pssh handle.
-
-    Notes:
-      - This fixture has module scope, so a single connection handle is reused for all tests in the module.
-    """
-    log.info("%s", cluster_dict)
-    env_vars = cluster_dict.get("env_vars")
-    node_list = list(cluster_dict['node_dict'].keys())
-    c_phdl = Pssh(log, node_list, user=cluster_dict['username'], pkey=cluster_dict['priv_key_file'], env_vars=env_vars)
-    return c_phdl
-
-
-@pytest.fixture(scope="module")
-def gpu_type(s_phdl, cluster_dict):
-    """
-    Provide the GPU type string for the test module.
-
-    Args:
-      cluster_dict (dict): Cluster configuration that includes the GPU type.
-
-    Returns:
-      str: The GPU type (e.g., 'mi300', 'mi300x') used to select model parameters and logic.
-
-    Notes:
-      - Module scope ensures this is evaluated once per test module.
-      - Consider validating this value against an expected set of GPU types to catch typos early.
-    """
-
-    log.info("%s", s_phdl)
-    log.info("%s", list(dir(s_phdl)))
-    head_node = s_phdl.host_list[0]
-    smi_out_dict = s_phdl.exec('rocm-smi -a | head -30')
-    smi_out = smi_out_dict[head_node]
-    gpu_type = get_model_from_rocm_smi_output(smi_out)
-    return gpu_type
-
-
-def test_cleanup_stale_containers(s_phdl, inference_dict):
-    """
-    Pytest: Clean up potentially stale Docker containers and volumes before tests.
-
-    Args:
-      s_phdl: Parallel SSH/process handle used by docker_lib to run commands on nodes.
-      inference_dict (dict): Training configuration dict that includes:
-        - 'container_name': Name of the container to be killed if running.
-
-    Behavior:
-      - Kills the specific container identified by inference_dict['container_name'].
-      - Deletes all containers and volumes on the target nodes (broad cleanup).
-
-    Notes:
-      - This performs a broad cleanup via delete_all_containers_and_volumes; ensure the
-        test environment is isolated so this doesn?t remove unrelated containers/volumes.
-      - Consider narrowing cleanup scope if other workloads may be present on the hosts.
-    """
-
-    container_name = inference_dict['container_name']
-    docker_lib.kill_docker_container(s_phdl, container_name)
-    docker_lib.delete_all_containers_and_volumes(s_phdl)
-
-
-def test_launch_inference_containers(s_phdl, inference_dict, benchmark_params_dict):
-    """
-    Launch InferenceMAX inference containers on all nodes.
-
-    Note: Container image can be model-specific or use global default.
-    """
-
-    log.info('Testcase launch InferenceMax containers')
-    globals.error_list = []
-    container_name = inference_dict['container_name']
-
-    # Get model-specific container image or use global default
-    container_image = benchmark_params_dict.get('gpt-oss-120b', {}).get(
-        'container_image', inference_dict['container_image']
-    )
-
-    # Launch the containers ..
-    docker_lib.launch_docker_container(
-        s_phdl,
-        container_name,
-        container_image,
-        inference_dict['container_config']['device_list'],
-        inference_dict['container_config']['volume_dict'],
-        inference_dict['container_config']['env_dict'],
-        shm_size='48G',
-        timeout=60 * 20,
-    )
-    # ADD verifications ..
-    time.sleep(30)
-    log.info('Verify if the containers have been launched properly')
-    out_dict = s_phdl.exec('docker ps')
-    for node in out_dict.keys():
-        if not re.search(f'{container_name}', out_dict[node], re.I):
-            fail_test(f'Failed to launch container on node {node}')
-    update_test_result()
-
-
-def test_gpt_oss_120_single_node(c_phdl, s_phdl, gpu_type, inference_dict, benchmark_params_dict, hf_token):
-    globals.error_list = []
-    im_obj = InferenceMaxJob(
-        c_phdl=c_phdl,
-        s_phdl=s_phdl,
-        model_name='gpt-oss-120b',
-        inference_config_dict=inference_dict,
-        benchmark_params_dict=benchmark_params_dict,
-        hf_token=hf_token,
-        gpu_type=gpu_type,
-        distributed_inference=False,
-    )
-    im_obj.build_server_inference_job_cmd()
-    im_obj.start_inference_server_job()
-    im_obj.start_inference_client_job()
-    im_obj.poll_for_inference_completion()
-    im_obj.verify_inference_results()
-    update_test_result()
diff --git a/cvs/tests/inference/inferencemax/inferencemax_single.py b/cvs/tests/inference/inferencemax/inferencemax_single.py
new file mode 100644
index 00000000..4d9ac7a7
--- /dev/null
+++ b/cvs/tests/inference/inferencemax/inferencemax_single.py
@@ -0,0 +1,249 @@
+'''
+Copyright 2025 Advanced Micro Devices, Inc.
+All rights reserved.
+'''
+
+import importlib.util as _ilu
+import json
+import os
+import pathlib as _pl
+import shlex
+import time
+
+import pytest
+
+from cvs.lib import globals
+from cvs.lib.inference.inferencemax_orch import InferenceMaxJob
+from cvs.lib.inference.utils.inferencing_config_loader import validate_sweep_selector
+from cvs.lib.inference.utils.vllm_parsing import CLIENT_METRICS as _METRICS, CLIENT_METRIC_UNITS as _METRIC_UNITS
+from cvs.lib.utils.verdict import evaluate_all
+
+_spec = _ilu.spec_from_file_location("_inferencemax_shared", _pl.Path(__file__).with_name("_shared.py"))
+_mod = _ilu.module_from_spec(_spec)
+_spec.loader.exec_module(_mod)
+test_print_results_table = _mod.test_print_results_table  # noqa: F841
+
+log = globals.log
+
+_FETCH_POLL_COUNT = 80
+_FETCH_POLL_WAIT_S = 30
+_FETCH_PRESENCE_RETRIES = 5
+
+
+def pytest_generate_tests(metafunc):
+    config_file = metafunc.config.getoption("config_file")
+    if not config_file or not os.path.isfile(config_file):
+        return
+    with open(config_file) as fp:
+        raw = json.load(fp)
+    sweep = raw.get("sweep", {})
+    combos = sweep.get("sequence_combinations", [])
+    runs = sweep.get("runs", [])
+    validate_sweep_selector([c["name"] for c in combos], [r["combo"] for r in runs])
+    by_name = {c["name"]: c for c in combos}
+    cases = []
+    ids = []
+    for run in runs:
+        combo = by_name[run["combo"]]
+        conc = run["concurrency"]
+        cases.append((combo, conc))
+        ids.append(run["combo"] + "-conc" + str(conc))
+    if "metric" in metafunc.fixturenames:
+        if cases:
+            metric_cases = []
+            metric_ids = []
+            for (combo, c), cid in zip(cases, ids):
+                for short, _unit in _METRICS:
+                    metric_cases.append((combo, c, short))
+                    metric_ids.append(cid + "-" + short)
+            metafunc.parametrize("seq_combo,concurrency,metric", metric_cases, ids=metric_ids)
+    elif "seq_combo" in metafunc.fixturenames and "concurrency" in metafunc.fixturenames and cases:
+        metafunc.parametrize("seq_combo,concurrency", cases, ids=ids)
+
+
+def _du_bytes(orch, path):
+    out = orch.exec(f"bash -c {shlex.quote(f'du -sb {shlex.quote(path)} 2>/dev/null | cut -f1')}")
+    total = 0
+    for text in (out or {}).values():
+        for tok in (text or "").split():
+            if tok.isdigit():
+                total = max(total, int(tok))
+    return total
+
+
+def test_launch_container(orch, lifecycle, request):
+    t = time.monotonic()
+    ok = orch.setup_containers()
+    lifecycle.record(request.node.nodeid, "container_launch", time.monotonic() - t)
+    if not ok:
+        lifecycle.failed = True
+        name = orch.get_container_name(orch.container_config, orch.container_config["image"])
+        pytest.fail(f"setup_containers() returned False for {name}")
+    name = orch.get_container_name(orch.container_config, orch.container_config["image"])
+    if not orch.verify_containers_running(name):
+        lifecycle.failed = True
+        pytest.fail(f"container {name} not running after setup_containers()")
+    time.sleep(30)
+
+
+def test_setup_sshd(orch, lifecycle, request):
+    if lifecycle.failed:
+        pytest.skip("a prior lifecycle stage failed")
+    t = time.monotonic()
+    ok = orch.setup_sshd()
+    lifecycle.record(request.node.nodeid, "sshd_setup", time.monotonic() - t)
+    if not ok:
+        lifecycle.failed = True
+        pytest.fail("setup_sshd() returned False")
+    if len(orch.hosts) > 1:
+        probe = orch.exec("bash -c 'ss -ltn 2>/dev/null | grep -q :2224 && echo OK || echo NO'")
+        if not any("OK" in (v or "") for v in (probe or {}).values()):
+            lifecycle.failed = True
+            pytest.fail("sshd not listening on 2224 after setup_sshd()")
+
+
+def test_model_fetch(orch, variant_config, lifecycle, request):
+    if lifecycle.failed:
+        pytest.skip("a prior lifecycle stage failed")
+    models_dir = variant_config.paths.models_dir
+    if not models_dir:
+        pytest.skip("paths.models_dir unset; cannot locate/verify the HF cache")
+
+    remote = getattr(variant_config.model, "remote", 0)
+    t = time.monotonic()
+    orch.exec(f"mkdir -p {shlex.quote(models_dir)}")
+
+    if not remote:
+        final = 0
+        for it in range(_FETCH_PRESENCE_RETRIES):
+            final = _du_bytes(orch, models_dir)
+            log.info("[fetch presence %d] size=%.1fGB", it, final / 1e9)
+            if final > 0:
+                break
+            time.sleep(_FETCH_POLL_WAIT_S)
+    else:
+        fetch = (
+            f"HF_HUB_CACHE={shlex.quote(models_dir)} "
+            f"nohup hf download {shlex.quote(variant_config.model.id)} "
+            f"> /tmp/hf_fetch.log 2>&1 &"
+        )
+        orch.exec("bash -c " + shlex.quote(fetch))
+        prev = -1
+        stable = 0
+        final = _du_bytes(orch, models_dir)
+        for it in range(_FETCH_POLL_COUNT):
+            cur = _du_bytes(orch, models_dir)
+            final = cur
+            log.info("[fetch poll %d] size=%.1fGB", it, cur / 1e9)
+            if cur > 0 and cur == prev:
+                stable += 1
+                if stable >= 2:
+                    break
+            else:
+                stable = 0
+            prev = cur
+            time.sleep(_FETCH_POLL_WAIT_S)
+
+    lifecycle.record(request.node.nodeid, "model_fetch", time.monotonic() - t)
+    lifecycle.record(request.node.nodeid, "model_size", final / 1e9, "GB")
+    if final <= 0:
+        lifecycle.failed = True
+        pytest.fail(f"no model bytes under {models_dir} after fetch")
+
+
+def test_inferencemax_inference(
+    orch,
+    variant_config,
+    hf_token,
+    seq_combo,
+    concurrency,
+    inf_res_dict,
+    lifecycle,
+    request,
+):
+    if lifecycle.failed:
+        pytest.skip("a prior lifecycle stage failed")
+
+    isl = seq_combo["isl"]
+    osl = seq_combo["osl"]
+    p = variant_config.params
+    job = InferenceMaxJob(
+        orch=orch,
+        variant=variant_config,
+        hf_token=hf_token,
+        isl=isl,
+        osl=osl,
+        concurrency=concurrency,
+        num_prompts=p.num_prompts,
+        client_poll_count=int(p.client_poll_count),
+        client_poll_wait_s=int(p.client_poll_wait_time),
+        bench_max_failed_requests=int(p.bench_max_failed_requests),
+    )
+
+    try:
+        job.stop_server()
+        job.build_server_cmd()
+        t = time.monotonic()
+        job.start_server()
+        job.wait_ready()
+        lifecycle.record(request.node.nodeid, "server_ready", time.monotonic() - t)
+        t_client = time.monotonic()
+        job.run_client()
+        job.wait_client_complete()
+        results = job.parse_results()
+    except Exception:
+        lifecycle.failed = True
+        raise
+
+    key = (
+        variant_config.model.id,
+        variant_config.gpu_arch,
+        isl,
+        osl,
+        seq_combo.get("name", "default"),
+        concurrency,
+    )
+    inf_res_dict[key] = results
+    lifecycle.record(request.node.nodeid, "client_complete", time.monotonic() - t_client)
+
+
+def test_metric(seq_combo, concurrency, metric, inf_res_dict, variant_config, lifecycle, request):
+    if lifecycle.failed:
+        pytest.skip("a prior lifecycle stage failed")
+    isl = seq_combo["isl"]
+    osl = seq_combo["osl"]
+    key = (
+        variant_config.model.id,
+        variant_config.gpu_arch,
+        isl,
+        osl,
+        seq_combo.get("name", "default"),
+        concurrency,
+    )
+    if key not in inf_res_dict:
+        pytest.skip(f"no recorded results for cell {key!r} (inference did not run)")
+    host_dict = inf_res_dict[key]
+    _host, actuals = next(iter(host_dict.items()))
+    full = "client." + metric
+    value = actuals.get(full)
+    unit = _METRIC_UNITS.get(metric, "-")
+    request.node.user_properties.append(("metric_value", value))
+    request.node.user_properties.append(("metric_unit", unit))
+
+    if not variant_config.enforce_thresholds:
+        return
+    cell = variant_config.cell_key(isl, osl, concurrency)
+    spec = (variant_config.thresholds.get(cell) or {}).get(full)
+    if spec is None:
+        return
+    evaluate_all(actuals, {full: spec})
+
+
+def test_teardown(orch, lifecycle, request):
+    name = orch.get_container_name(orch.container_config, orch.container_config["image"])
+    t = time.monotonic()
+    orch.teardown_containers()
+    lifecycle.record(request.node.nodeid, "teardown", time.monotonic() - t)
+    if orch.verify_containers_running(name):
+        pytest.fail(f"container {name} still running after teardown_containers()")
+    lifecycle.torn_down = True
diff --git a/cvs/tests/inference/vllm/_shared.py b/cvs/tests/inference/vllm/_shared.py
index 8e509054..c8d1d062 100644
--- a/cvs/tests/inference/vllm/_shared.py
+++ b/cvs/tests/inference/vllm/_shared.py
@@ -2,7 +2,7 @@
 Copyright 2025 Advanced Micro Devices, Inc.
 All rights reserved.
 
-Shared test helpers for the dtni vllm_single suite.
+Shared test helpers for the vllm_single suite.
 
 `test_print_results_table` is exported via `from ._shared import *` so each
 framework-specific suite file picks it up as a sibling test that pytest
@@ -18,6 +18,12 @@
 __all__ = ["test_print_results_table"]
 
 
+def _cell(m, key):
+    """Table cell: a missing OR present-but-None metric renders as '-'."""
+    v = m.get(key)
+    return "-" if v is None else v
+
+
 def test_print_results_table(inf_res_dict):
     if not inf_res_dict:
         log.info("inf_res_dict empty, nothing to print")
@@ -33,8 +39,11 @@ def test_print_results_table(inf_res_dict):
         "Req/s",
         "Total tok/s",
         "Mean TTFT (ms)",
+        "P95 TTFT (ms)",
         "Mean TPOT (ms)",
+        "P95 TPOT (ms)",
         "P99 ITL (ms)",
+        "Goodput (req/s)",
     ]
     rows = []
     for key, host_dict in inf_res_dict.items():
@@ -49,11 +58,14 @@ def test_print_results_table(inf_res_dict):
                     policy,
                     conc,
                     host,
-                    m.get("request_throughput_per_sec", "-"),
-                    m.get("total_throughput_per_sec", "-"),
-                    m.get("mean_ttft_ms", "-"),
-                    m.get("mean_tpot_ms", "-"),
-                    m.get("p99_itl_ms", "-"),
+                    _cell(m, "client.request_throughput"),
+                    _cell(m, "client.total_token_throughput"),
+                    _cell(m, "client.mean_ttft_ms"),
+                    _cell(m, "client.p95_ttft_ms"),
+                    _cell(m, "client.mean_tpot_ms"),
+                    _cell(m, "client.p95_tpot_ms"),
+                    _cell(m, "client.p99_itl_ms"),
+                    _cell(m, "client.goodput"),
                 ]
             )
     log.info("\n" + tabulate(rows, headers=headers, tablefmt="github"))
diff --git a/cvs/tests/inference/vllm/conftest.py b/cvs/tests/inference/vllm/conftest.py
index a6b3d06e..01c6dd71 100644
--- a/cvs/tests/inference/vllm/conftest.py
+++ b/cvs/tests/inference/vllm/conftest.py
@@ -10,7 +10,7 @@
 
 from cvs.core.orchestrators.factory import OrchestratorConfig, OrchestratorFactory
 from cvs.lib import globals
-from cvs.lib.dtni.config_loader import load_variant
+from cvs.lib.inference.utils.inferencing_config_loader import load_variant
 from cvs.lib.utils_lib import resolve_cluster_config_placeholders
 
 log = globals.log
@@ -96,7 +96,6 @@ def orch(cluster_dict, variant_config, lifecycle):
         cluster_dict.get("container", {}),
         variant_config.container.model_dump(),
     )
-    container_block["image"] = variant_config.image.tag
     testsuite_config = {
         "orchestrator": "container",
         "container": container_block,
@@ -137,8 +136,9 @@ def pytest_collection_modifyitems(items):
         "test_setup_sshd": 1,
         "test_model_fetch": 2,
         "test_vllm_inference": 3,
-        "test_print_results_table": 4,
-        "test_teardown": 5,
+        "test_metric": 4,
+        "test_print_results_table": 5,
+        "test_teardown": 6,
     }
     items.sort(key=lambda it: rank.get(it.originalname or it.name.split("[")[0], 99))
 
@@ -170,3 +170,31 @@ def pytest_runtest_makereport(item, call):
     extras = getattr(report, "extras", [])
     extras.append(pytest_html.extras.html(html))
     report.extras = extras
+
+
+def pytest_html_results_table_header(cells):
+    """Add Value + Unit columns just before the trailing Links column.
+
+    Populated for test_metric rows; blank for lifecycle/inference rows (they
+    record no metric_value user-property). Scoped to this suite's conftest, so
+    other suites' result tables are unaffected.
+    """
+    cells.insert(-1, "<th>Value</th>")
+    cells.insert(-1, "<th>Unit</th>")
+
+
+def pytest_html_results_table_row(report, cells):
+    props = dict(report.user_properties)
+    has = "metric_value" in props
+    val = props.get("metric_value")
+    unit = props.get("metric_unit", "") if has else ""
+    if not has:
+        shown = ""
+    elif val is None:
+        shown = "-"
+    elif isinstance(val, float):
+        shown = f"{val:.3f}"
+    else:
+        shown = str(val)
+    cells.insert(-1, f"<td>{shown}</td>")
+    cells.insert(-1, f"<td>{unit}</td>")
diff --git a/cvs/tests/inference/vllm/vllm_single.py b/cvs/tests/inference/vllm/vllm_single.py
index 01768b04..c82ff1a4 100644
--- a/cvs/tests/inference/vllm/vllm_single.py
+++ b/cvs/tests/inference/vllm/vllm_single.py
@@ -13,13 +13,15 @@
 import pytest
 
 from cvs.lib import globals
-from cvs.lib.dtni.verdict import evaluate_all
+from cvs.lib.inference.utils.inferencing_config_loader import GoodputSlo, validate_sweep_selector
+from cvs.lib.utils.verdict import evaluate_all
+from cvs.lib.inference.utils.vllm_parsing import CLIENT_METRICS as _METRICS, CLIENT_METRIC_UNITS as _METRIC_UNITS
 from cvs.lib.inference.vllm_orch import VllmJob
 
 import importlib.util as _ilu
 import pathlib as _pl
 
-_spec = _ilu.spec_from_file_location("_dtni_vllm_shared", _pl.Path(__file__).with_name("_shared.py"))
+_spec = _ilu.spec_from_file_location("_vllm_shared", _pl.Path(__file__).with_name("_shared.py"))
 _mod = _ilu.module_from_spec(_spec)
 _spec.loader.exec_module(_mod)
 test_print_results_table = _mod.test_print_results_table  # exported as a sibling test  # noqa: F841
@@ -34,14 +36,19 @@
 _FETCH_PRESENCE_RETRIES = 5
 
 
+
 def pytest_generate_tests(metafunc):
-    """Parametrize test_vllm_inference over sequence_combinations × concurrency_levels.
+    """Parametrize test_vllm_inference from the sweep's named-combo + runs selector.
 
     Lives in the suite module (not conftest) because it parametrizes fixtures
     only test_vllm_inference consumes -- co-locating the parametrization with
     its sole consumer. It runs at collection time, before fixtures exist, so it
     reads the raw config_file JSON directly (it cannot use the variant_config
     fixture / the typed loader).
+
+    The sweep lists `sequence_combinations` (each with a `name`) once and a
+    `runs` array of `{combo, concurrency}` pairs; one case is emitted per run.
+    No NxM cartesian -- exactly the cells `runs` enumerates.
     """
     config_file = metafunc.config.getoption("config_file")
     if not config_file or not os.path.isfile(config_file):
@@ -50,15 +57,37 @@ def pytest_generate_tests(metafunc):
         raw = json.load(fp)
     sweep = raw.get("sweep", {})
     combos = sweep.get("sequence_combinations", [])
-    concs = sweep.get("concurrency_levels", [])
+    runs = sweep.get("runs", [])
+    # Validate each raw goodput_slo dict through the same _Forbid model the
+    # typed loader uses. pytest_generate_tests bypasses load_variant (it reads
+    # raw JSON at collection time), so without this a typo'd SLO key would be
+    # silently dropped and a wrong goodput gate would run on hardware.
+    for combo in combos:
+        if combo.get("goodput_slo") is not None:
+            GoodputSlo(**combo["goodput_slo"])
+    # Mirror the typed Sweep validator here (this path reads raw JSON before
+    # load_variant runs) via the shared rule so the two cannot drift: a
+    # duplicate combo name or a run referencing an unknown combo must fail
+    # collection, not silently drop.
+    validate_sweep_selector([c["name"] for c in combos], [r["combo"] for r in runs])
+    by_name = {c["name"]: c for c in combos}
     cases = []
     ids = []
-    for combo in combos:
-        default_name = "isl" + combo["isl"] + "_osl" + combo["osl"]
-        for c in concs:
-            cases.append((combo, c))
-            ids.append(combo.get("name", default_name) + "-conc" + str(c))
-    if "seq_combo" in metafunc.fixturenames and "concurrency" in metafunc.fixturenames and cases:
+    for run in runs:
+        combo = by_name[run["combo"]]
+        conc = run["concurrency"]
+        cases.append((combo, conc))
+        ids.append(run["combo"] + "-conc" + str(conc))
+    if "metric" in metafunc.fixturenames:
+        if cases:
+            metric_cases = []
+            metric_ids = []
+            for (combo, c), cid in zip(cases, ids):
+                for short, _unit in _METRICS:
+                    metric_cases.append((combo, c, short))
+                    metric_ids.append(cid + "-" + short)
+            metafunc.parametrize("seq_combo,concurrency,metric", metric_cases, ids=metric_ids)
+    elif "seq_combo" in metafunc.fixturenames and "concurrency" in metafunc.fixturenames and cases:
         metafunc.parametrize("seq_combo,concurrency", cases, ids=ids)
 
 
@@ -93,7 +122,7 @@ def test_launch_container(orch, variant_config, lifecycle, request):
 
 
 def test_setup_sshd(orch, lifecycle, request):
-    """Stage 2: start sshd in the container. Asserts the daemon is reachable on 2224."""
+    """Stage 2: start sshd in the container (multinode only; single-node skips it)."""
     if lifecycle.failed:
         pytest.skip("a prior lifecycle stage failed")
     t = time.monotonic()
@@ -102,10 +131,13 @@ def test_setup_sshd(orch, lifecycle, request):
     if not ok:
         lifecycle.failed = True
         pytest.fail("setup_sshd() returned False")
-    probe = orch.exec("bash -c 'ss -ltn 2>/dev/null | grep -q :2224 && echo OK || echo NO'")
-    if not any("OK" in (v or "") for v in (probe or {}).values()):
-        lifecycle.failed = True
-        pytest.fail("sshd not listening on 2224 after setup_sshd()")
+    # Single-node runs skip starting the in-container sshd (it exists only for
+    # inter-node MPI), so only probe 2224 when there is more than one host.
+    if len(orch.hosts) > 1:
+        probe = orch.exec("bash -c 'ss -ltn 2>/dev/null | grep -q :2224 && echo OK || echo NO'")
+        if not any("OK" in (v or "") for v in (probe or {}).values()):
+            lifecycle.failed = True
+            pytest.fail("sshd not listening on 2224 after setup_sshd()")
 
 
 def test_model_fetch(orch, variant_config, lifecycle, request):
@@ -184,6 +216,7 @@ def test_vllm_inference(orch, variant_config, hf_token, seq_combo, concurrency,
         osl=osl,
         concurrency=concurrency,
         num_prompts=_num_prompts_for(osl, concurrency),
+        goodput_slo=seq_combo.get("goodput_slo"),
         client_poll_count=int(variant_config.params.client_poll_count),
     )
 
@@ -214,22 +247,56 @@ def test_vllm_inference(orch, variant_config, hf_token, seq_combo, concurrency,
         concurrency,
     )
     inf_res_dict[key] = results
+    # Verdict is no longer asserted here: each metric is its own test (test_metric,
+    # one HTML row per metric per cell). This test only runs the benchmark and
+    # records the cell's results into the module-scoped inf_res_dict.
+
+
+def test_metric(seq_combo, concurrency, metric, inf_res_dict, variant_config, lifecycle, request):
+    """One pytest test (= one HTML row) per perf metric per cell.
+
+    The benchmark already ran once in test_vllm_inference and stashed its results
+    in the module-scoped inf_res_dict; this reads a single cached metric and
+    surfaces it as its own pass/fail row. The value is rendered inline via the
+    Value/Unit table columns (pytest_html_results_table_row in conftest). No GPU
+    work. Skips cleanly when the cell's inference failed/skipped so a missing cell
+    never reports a false green.
+
+    Verdict: when enforce_thresholds is true AND a spec exists for this cell+metric
+    the value is asserted via the shared evaluate_all; otherwise the row is a
+    record-only PASS that simply displays the number. evaluate_all is handed the
+    full per-cell actuals (not just this one metric) so a min_ratio spec can still
+    resolve its reference metric.
+    """
+    if lifecycle.failed:
+        pytest.skip("a prior lifecycle stage failed")
+    isl = seq_combo["isl"]
+    osl = seq_combo["osl"]
+    key = (
+        variant_config.model.id,
+        variant_config.gpu_arch,
+        isl,
+        osl,
+        seq_combo.get("name", "default"),
+        concurrency,
+    )
+    if key not in inf_res_dict:
+        pytest.skip(f"no recorded results for cell {key!r} (inference did not run)")
+    host_dict = inf_res_dict[key]
+    _host, actuals = next(iter(host_dict.items()))
+    full = "client." + metric
+    value = actuals.get(full)
+    unit = _METRIC_UNITS.get(metric, "-")
+    request.node.user_properties.append(("metric_value", value))
+    request.node.user_properties.append(("metric_unit", unit))
 
-    # Per-cell thresholds: thresholds layout is `{"ISL=...,OSL=...,TP=...,CONC=...": {metric: spec}}`.
-    # The key is built by VariantConfig.cell_key (the same builder the loader uses for its
-    # coverage check). When enforce_thresholds is true a missing cell is a hard error -- never
-    # a silent skip that would report a green PASS with no assertions. When it is false the
-    # config is a record-only scaffold (un-calibrated thresholds): capture the metrics and
-    # skip the verdict.
     if not variant_config.enforce_thresholds:
-        log.info("enforce_thresholds=false; recorded metrics for cell, skipping verdict")
         return
     cell = variant_config.cell_key(isl, osl, concurrency)
-    cell_thresholds = variant_config.thresholds.get(cell)
-    if not cell_thresholds:
-        raise AssertionError(f"no thresholds for cell {cell!r}; threshold file is out of sync with the sweep")
-    for host, actuals in results.items():
-        evaluate_all(actuals, cell_thresholds)
+    spec = (variant_config.thresholds.get(cell) or {}).get(full)
+    if spec is None:
+        return
+    evaluate_all(actuals, {full: spec})
 
 
 def test_teardown(orch, lifecycle, request):
diff --git a/docs/how-to/run-cvs-tests.rst b/docs/how-to/run-cvs-tests.rst
index 9b5f18ff..433701c1 100644
--- a/docs/how-to/run-cvs-tests.rst
+++ b/docs/how-to/run-cvs-tests.rst
@@ -42,7 +42,7 @@ You can list available tests using either `cvs run` (with no arguments) or `cvs
       • install_ibperf_tools
   
     cvs.tests.inference.inferencemax (1 test suite)
-      • inferencemax_gpt_oss_120b_single
+      • inferencemax_single
   
     cvs.tests.inference.pytorch_xdit (2 test suites)
       • pytorch_xdit_flux1_dev_single
@@ -52,11 +52,8 @@ You can list available tests using either `cvs run` (with no arguments) or `cvs
       • sglang_deepseek_r1_671b_distributed
       • sglang_llama_70b_distributed
   
-    cvs.tests.inference.vllm (4 test suites)
-      • vllm_deepseek31_685b_single
-      • vllm_gpt_oss_120b_single
-      • vllm_qwen3_235b_single
-      • vllm_qwen3_80b_single
+    cvs.tests.inference.vllm (1 test suite)
+      • vllm_single
   
     cvs.tests.mori (1 test suite)
       • mori_benchmark_test
@@ -80,7 +77,7 @@ You can list available tests using either `cvs run` (with no arguments) or `cvs
       • megatron_llama3_1_8b_single
   
   ================================================================================
-  Total: 34 test suites across 1 package(s)
+  Total: 29 test suites across 1 package(s)
 
 
 Run all tests in a file:
@@ -635,20 +632,22 @@ You can list all available Inferencemax test cases using the CLI:
 
 .. code:: bash
 
-  cvs list inferencemax_gpt_oss_120b_single
+  cvs list inferencemax_single
 
 .. code:: text
 
-  Available tests in inferencemax_gpt_oss_120b_single:
-    - test_cleanup_stale_containers
-    - test_gpt_oss_120_single_node
-    - test_launch_inference_containers
+  Available tests in inferencemax_single:
+    - test_launch_container
+    - test_inferencemax_inference
+    - test_print_results_table
+    - test_teardown
 
-Use these scripts to run the Inferencemax tests.
+Use these scripts to run the Inferencemax tests. Supply your own suite JSON
+(``config`` + ``benchmark_params``); see :doc:`../reference/configuration-files/inferencemax`.
 
 .. code:: bash
 
-  cvs run inferencemax_gpt_oss_120b_single --cluster_file input/cluster_file/cluster.json --config_file input/config_file/inference/inferencemax/mi300x_inferencemax_gpt_oss_120b_single.json --html=/var/www/html/cvs/inferencemax.html --capture=tee-sys --self-contained-html --log-file=/tmp/inferencemax.log -vvv -s
+  cvs run inferencemax_single --cluster_file input/cluster_file/cluster.json --config_file input/config_file/inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_config.json --html=/var/www/html/cvs/inferencemax.html --capture=tee-sys --self-contained-html --log-file=/tmp/inferencemax.log -vvv -s
 
 
 Pytorch xdit test scripts
@@ -748,73 +747,34 @@ Use these scripts to run the Sglang tests.
 VLLM test scripts
 ------------------------------
 
-You can list all available VLLM test cases using the CLI:
+Single-node vLLM benchmarks use one parametrized suite, ``vllm_single``. Each **variant**
+is a directory under ``cvs/input/config_file/inference/vllm_single/<variant>/`` containing
+``*_config.json`` and a sibling ``*_threshold.json`` (see :func:`cvs.lib.inference.utils.inferencing_config_loader.load_variant` for vLLM, or :func:`cvs.lib.inference.utils.inferencemax_config_loader.load_variant` for InferenceMax).
+Point ``--config_file`` at the variant's ``*_config.json`` and ``--cluster_file`` at a cluster
+JSON that matches your hardware (for example ``input/cluster_file/mi300x_vllm_single.json``).
 
 .. code:: bash
 
-  cvs list vllm_deepseek31_685b_single
+  cvs list vllm_single
 
 .. code:: text
 
-  Available tests in vllm_deepseek31_685b_single:
-    - test_cleanup_stale_containers
-    - test_launch_inference_containers
+  Available tests in vllm_single:
+    - test_launch_container
+    - test_setup_sshd
+    - test_model_fetch
+    - test_vllm_inference[throughput-conc64]
+    - test_vllm_inference[throughput-conc128]
+    - test_vllm_inference[throughput-conc256]
     - test_print_results_table
-    - test_vllm_inference
-
-.. code:: bash
-
-  cvs list vllm_gpt_oss_120b_single
-
-.. code:: text
-
-  Available tests in vllm_gpt_oss_120b_single:
-    - test_cleanup_stale_containers
-    - test_launch_inference_containers
-    - test_print_results_table
-    - test_vllm_inference
-    
-.. code:: bash
-
-  cvs list vllm_qwen3_235b_single
-
-.. code:: text
-
-  Available tests in vllm_qwen3_235b_single:
-    - test_cleanup_stale_containers
-    - test_launch_inference_containers
-    - test_print_results_table
-    - test_vllm_inference
-
-.. code:: bash
-
-  cvs list vllm_qwen3_80b_single
-
-.. code:: text
-
-  Available tests in vllm_qwen3_80b_single:
-    - test_cleanup_stale_containers
-    - test_launch_inference_containers
-    - test_print_results_table
-    - test_vllm_inference
-
-Use these scripts to run the VLLM tests.
-
-.. code:: bash
-
-  cvs run vllm_deepseek31_685b_single --cluster_file input/cluster_file/cluster.json --config_file input/config_file/inference/vllm/mi355x_vllm_single.json --html=/var/www/html/cvs/deepseek.html --capture=tee-sys --self-contained-html --log-file=/tmp/deepseek.log -vvv -s
-
-.. code:: bash
-
-  cvs run vllm_gpt_oss_120b_single --cluster_file input/cluster_file/cluster.json --config_file input/config_file/inference/vllm/mi355x_vllm_single.json --html=/var/www/html/cvs/gpt.html --capture=tee-sys --self-contained-html --log-file=/tmp/gpt.log -vvv -s
-
-.. code:: bash
+    - test_teardown
 
-  cvs run vllm_qwen3_235b_single --cluster_file input/cluster_file/cluster.json --config_file input/config_file/inference/vllm/mi355x_vllm_single.json --html=/var/www/html/cvs/qwen235.html --capture=tee-sys --self-contained-html --log-file=/tmp/qwen235.log -vvv -s
+The ``test_vllm_inference[...]`` names come from the ``sweep`` block in the variant config
+(sequence combination ``name`` plus ``conc``); your list may differ if you use another variant.
 
 .. code:: bash
 
-  cvs run vllm_qwen3_80b_single --cluster_file input/cluster_file/cluster.json --config_file input/config_file/inference/vllm/mi355x_vllm_single.json --html=/var/www/html/cvs/qwen80.html --capture=tee-sys --self-contained-html --log-file=/tmp/qwen80.log -vvv -s
+  cvs run vllm_single --cluster_file input/cluster_file/mi300x_vllm_single.json --config_file input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/w1_llama31_70b_fp8kv_config.json --html=/var/www/html/cvs/vllm_single.html --capture=tee-sys --self-contained-html --log-file=/tmp/vllm_single.log -vvv -s
 
 
 Test results
diff --git a/docs/install/cvs-install.rst b/docs/install/cvs-install.rst
index 01121cdf..dae34ef9 100644
--- a/docs/install/cvs-install.rst
+++ b/docs/install/cvs-install.rst
@@ -309,13 +309,14 @@ CVS provides comprehensive inference testing configurations for various LLM serv
 
 **InferenceMAX (vLLM Benchmarking)**
 
-1. Copy the InferenceMAX configuration file:
+1. Copy the InferenceMAX configuration files (``*_config.json`` and optional sibling ``*_threshold.json``):
 
    .. code:: bash
 
-     cvs copy-config inference/mi300x_singlenode_inferencemax.json --output ~/my_inferencemax_config.json
+     cvs copy-config inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_config.json --output ~/my_inferencemax_config.json
+     cvs copy-config inference/inferencemax_single/mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_threshold.json --output ~/my_inferencemax_threshold.json
 
-2. Edit the file and modify these parameters:
+2. Edit the files and modify these parameters:
 
    - ``container_image``: Docker image with vLLM
    - ``nnodes``: Number of nodes in the cluster
diff --git a/docs/reference/configuration-files/inferencemax.rst b/docs/reference/configuration-files/inferencemax.rst
index 7ae850e8..2a1a7853 100644
--- a/docs/reference/configuration-files/inferencemax.rst
+++ b/docs/reference/configuration-files/inferencemax.rst
@@ -1,5 +1,4 @@
-.. meta::
-  :description: Configure the variables in the InferenceMAX configuration files
+.. meta::  :description: Configure the variables in the InferenceMAX configuration files
   :keywords: inference, ROCm, install, cvs, InferenceMAX, vLLM
 
 ***************************************
@@ -16,195 +15,123 @@ The InferenceMAX tests check:
 - **Benchmarking**: Load testing with various concurrency levels and sequence lengths
 - **Result verification**: Expected throughput and latency metrics
 
-Change the parameters as needed in the InferenceMAX configuration file: ``mi300x_singlenode_inferencemax.json`` for single node inference configurations.
+InferenceMAX inputs use per-variant directories under ``cvs/input/config_file/inference/inferencemax_single/<variant>/`` with a suite JSON passed as ``--config_file`` (typically ``<variant>_config.json``). Pass/fail numbers live in the **sole** ``*threshold.json`` in that directory (loaded by :func:`cvs.lib.inference.utils.inferencemax_config_loader.load_variant`). For example, MI300X GPT-OSS 120B single-node uses ``mi300x_gpt_oss_120b_single/mi300x_gpt_oss_120b_single_config.json`` plus ``mi300x_gpt_oss_120b_single_threshold.json``.
 
-.. note::
+**InferenceX ATOM / M.. note::
 
   - Parameters with the ``<changeme>`` value must have that value modified to your specifications.
   - ``{user-id}`` will be resolved to the current username in the runtime. You can also manually change this value to your username.
+  - **Server**: ``roles.server.serve_args`` and ``roles.server.env`` drive a Python-built ``vllm serve`` command inside the container (same pattern as ``vllm_single``). MI300-class defaults include ``enforce-eager``, ``block-size``, and ``no-enable-prefix-caching``.
+  - **Thresholds**: sibling ``*threshold.json`` in the variant directory (exactly one file; multiple files is an error). Loaded by :func:`cvs.lib.inference.utils.inferencemax_config_loader.load_variant`. Cell keys use ``ISL=<isl>,OSL=<osl>,TP=<tp>,CONC=<conc>`` with ``client.*`` metric specs (see vLLM threshold examples). ``test_metric`` asserts via :func:`cvs.lib.utils.verdict.evaluate_all` when ``enforce_thresholds`` is true.
+  - **Sweep**: ``sweep.sequence_combinations`` (named ISL/OSL pairs) plus ``sweep.runs`` (explicit ``{combo, concurrency}`` list). Model id comes from ``model.id``.
 
-``mi300x_singlenode_inferencemax.json``
-========================================
+Pytest and HTML layout (inferencemax_single)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Here's a code snippet of the ``mi300x_singlenode_inferencemax.json`` file for reference:
+.. list-table::
+   :widths: 10 35 55
+   :header-rows: 1
 
-.. dropdown:: ``mi300x_singlenode_inferencemax.json``
+   * - Stage
+     - Test
+     - Notes
+   * - 1
+     - ``test_launch_container``
+     - Host ``docker_lib`` launch; records ``container_launch``.
+   * - 2
+     - ``test_setup_sshd``
+     - Multinode only; single-node skips sshd probe.
+   * - 3
+     - ``test_model_fetch``
+     - Ensures model bytes are present under ``paths.models_dir``.
+   * - 4
+     - ``test_inferencemax_inference``
+     - Parametrized cell; records ``server_ready`` then ``client_complete``.
+   * - 5
+     - ``test_metric``
+     - One HTML row per ``client.*`` metric per cell.
+   * - 6
+     - ``test_print_results_table``
+     - Session results grid from ``inf_res_dict``.
+   * - 7
+     - ``test_teardown``
+     - Explicit teardown; sets ``lifecycle.torn_down`` after verify.
+
+Example variant layout
+======================
+
+Each variant directory contains ``<variant>_config.json`` (``schema_version: 1``) and a sibling ``<variant>_threshold.json``. See ``mi300x_gpt_oss_120b_single/`` for a calibrated GPT-OSS 120B reference.
+
+.. dropdown:: Example ``mi300x_gpt_oss_120b_single_threshold.json`` (excerpt)
 
   .. code:: json
 
     {
-        "config": {
-            "container_image": "rocm/7.0:rocm7.0_ubuntu_22.04_vllm_0.10.1_instinct_20250927_rc1",
-            "container_name": "inference_max_rocm",
-            "_example_nnodes": "4",
-            "nnodes": "4",
-            "inferencemax_repo": "https://github.com/InferenceMAX/InferenceMAX.git",
-            "benchmark_script_repo": "https://github.com/kimbochen/bench_serving.git",
-            "hf_token_file": "/home/{user-id}/.hf_token",
-            "shm_size": "128G",
-            "log_dir": "/home/{user-id}/LOGS",
-            "container_config": {
-                "device_list": [
-                    "/dev/dri",
-                    "/dev/kfd"
-                ],
-                "volume_dict": {
-                    "/home/{user-id}": "/home/{user-id}"
-                },
-                "env_dict": {}
-            }
-        },
-        "benchmark_params": {
-            "gpt-oss-120b": {
-                "backend": "vllm",
-                "base_url": "http://0.0.0.0",
-                "port_no": "8000",
-                "_example_dataset_name": "sharegpt|hf|random|sonnet|burstgpt",
-                "dataset_name": "random",
-                "max_concurrency": "64",
-                "model": "openai/gpt-oss-120b",
-                "num_prompts": "1000",
-                "input_sequence_length": "8192",
-                "output_sequence_length": "1024",
-                "burstiness": "1.0",
-                "seed": "0",
-                "max_model_length": "9216",
-                "random_range_ratio": "0.8",
-                "random_prefix_len": "0",
-                "tensor_parallelism": "8",
-                "_example_tokenizer_mode": "auto|slow|mistral|custom",
-                "tokenizer_mode": "auto",
-                "percentiles_metrics": "ttft,tpot,itl,e2el",
-                "metric_percentiles": "99",
-                "server_script": "gptoss_fp4_mi300x_docker.sh",
-                "bench_serv_script": "benchmark_serving.py",
-                "result_dict": {
-                    "output_throughput_per_sec": "4200",
-                    "mean_ttft_ms": "500",
-                    "mean_tpot_ms": "15"
-                }
-            }
-        }
+      "ISL=7168,OSL=1024,TP=8,CONC=64": {
+        "client.output_throughput": {"kind": "min_tok_s", "value": 4200},
+        "client.mean_ttft_ms": {"kind": "max_ms", "value": 500},
+        "client.mean_tpot_ms": {"kind": "max_ms", "value": 15}
+      }
     }
 
+  Every member of ``GATED_METRICS`` needs a spec in each cell (see the shipped file for the full set). Set ``enforce_thresholds: false`` in ``*_config.json`` until numbers are calibrated.
+
 Parameters
 ==========
 
-Use the parameters in this table to configure the InferenceMAX configuration file.
-
-.. |br| raw:: html
-
-    <br />
+Top-level blocks match the vLLM single-node schema (see ``plans/building-a-cvs-test-suite.md``). InferenceMax-specific notes:
 
 .. list-table::
    :widths: 3 3 5
    :header-rows: 1
 
-   * - Configuration parameters
-     - Default values
+   * - Block / key
+     - Example
      - Description
-   * - ``container_image``
-     - rocm/7.0:rocm7.0_ubuntu_22.04_ |br| vllm_0.10.1_instinct_20250927_rc1
-     - Docker container image with ROCm and vLLM for inference
-   * - ``container_name``
-     - inference_max_rocm
-     - Name of the Docker container instance
-   * - ``nnodes``
-     - 4
-     - Number of nodes in the cluster
-   * - ``inferencemax_repo``
-     - https://github.com/InferenceMAX/ |br| InferenceMAX.git
-     - Git repository URL for InferenceMAX framework
-   * - ``benchmark_script_repo``
-     - https://github.com/kimbochen/ |br| bench_serving.git
-     - Git repository URL for benchmarking scripts
-   * - ``hf_token_file``
-     - ``/home/{user-id}/`` |br| ``.hf_token``
-     - Path to HuggingFace authentication token file for model access
-   * - ``shm_size``
-     - 128G
-     - Shared memory size allocated to the container
-   * - ``log_dir``
-     - ``/home/{user-id}/LOGS``
-     - Directory where inference logs are stored
-   * - ``container_config.`` |br| ``device_list``
-     - Values: |br| - ``"/dev/dri"`` |br| - ``"/dev/kfd"``
-     - List of device paths to mount in the container for GPU access
-   * - ``container_config.`` |br| ``volume_dict``
-     - ``{"/home/{user-id}": "/home/{user-id}"}``
-     - Dictionary mapping host paths to container paths for volume mounts
-   * - ``/home/{user-id}``
-     - ``/home/{user-id}``
-     - User home directory mount
-   * - ``container_config.`` |br| ``env_dict``
-     - Empty
-     - Dictionary of environment variables to set in the container
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.backend``
-     - vllm
-     - Inference backend to use (vLLM)
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.base_url``
-     - http://0.0.0.0
-     - Base URL for the inference server
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.port_no``
-     - 8000
-     - Port number for the inference server
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``dataset_name``
-     - random
-     - Dataset type for benchmarking (sharegpt, hf, random, sonnet, burstgpt)
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``max_concurrency``
-     - 64
-     - Maximum number of concurrent requests during benchmarking
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.model``
-     - openai/gpt-oss-120b
-     - HuggingFace model identifier or path
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``num_prompts``
-     - 1000
-     - Total number of prompts to send during the benchmark
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``input_sequence_length``
-     - 8192
-     - Length of input sequences in tokens
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``output_sequence_`` |br| ``length``
-     - 1024
-     - Expected length of output sequences in tokens
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.burstiness``
-     - 1.0
-     - Request burstiness factor (1.0 = uniform distribution)
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.seed``
-     - 0
-     - Random seed for reproducible benchmark results
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``max_model_length``
-     - 9216
-     - Maximum total sequence length the model can handle
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``random_range_ratio``
-     - 0.8
-     - Range ratio for random dataset generation
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``random_prefix_len``
-     - 0
-     - Prefix length for random dataset generation
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``tensor_parallelism``
-     - 8
-     - Number of GPUs to use for tensor parallelism
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``tokenizer_mode``
-     - auto
-     - Tokenizer mode (auto, slow, mistral, custom)
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``percentiles_metrics``
-     - ttft,tpot,itl,e2el
-     - Comma-separated list of metrics to compute percentiles for (ttft: Time to First Token, tpot: Time Per Output Token, itl: Inter-Token Latency, e2el: End-to-End Latency)
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``metric_percentiles``
-     - 99
-     - Percentile values to compute for metrics (e.g., 99 for 99th percentile)
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.server_script``
-     - gptoss_fp4_mi300x_docker.sh
-     - Script to launch the inference server
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.`` |br| ``bench_serv_script``
-     - benchmark_serving.py
-     - Script to run the benchmarking client
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.result_dict.`` |br| ``output_throughput_`` |br| ``per_sec``
-     - 4200
-     - Expected number of output tokens generated per second
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.result_dict.`` |br| ``mean_ttft_ms``
-     - 500
-     - Expected mean Time to First Token in milliseconds
-   * - ``benchmark_params.`` |br| ``gpt-oss-120b.result_dict.`` |br| ``mean_tpot_ms``
-     - 15
-     - Expected mean Time Per Output Token in milliseconds
+   * - ``framework``
+     - ``inferencemax_single``
+     - Suite identifier passed to the loader.
+   * - ``enforce_thresholds``
+     - ``false``
+     - When false, ``test_metric`` records ``client.*`` values without asserting. Flip to ``true`` after calibrating ``*_threshold.json``.
+   * - ``paths.*``
+     - ``shared_fs``, ``models_dir``, ``log_dir``, ``hf_token_file``
+     - Placeholder-substituted paths. ``models_dir`` is the HF cache pin for serve and fetch.
+   * - ``model.id``
+     - ``openai/gpt-oss-120b``
+     - HuggingFace model id passed to ``vllm serve`` and ``vllm bench serve``.
+   * - ``container.image`` / ``container.name``
+     - ``<changeme>``
+     - Docker image and container name (set per environment).
+   * - ``container.runtime.args``
+     - ``shm_size``, ``volumes``, ``devices``
+     - Bind **only** ``/home/{user-id}:/home/{user-id}`` in ``volumes``; the orchestrator also mounts ``/home/<user>:/workspace``.
+   * - ``roles.server.serve_args``
+     - ``enforce-eager``, ``gpu-memory-utilization``, ``block-size``
+     - Extra ``vllm serve`` flags (Python-built; no host ``.sh`` staging).
+   * - ``roles.server.env``
+     - ``VLLM_ROCM_USE_AITER``, etc.
+     - Container env merged into ``/tmp/server_env_script.sh`` before launch.
+   * - ``params.tensor_parallelism``
+     - ``8``
+     - Tensor-parallel size for serve and bench; appears in threshold cell keys as ``TP``.
+   * - ``params.max_model_length``
+     - ``8192``
+     - Passed to ``vllm serve --max-model-len``. ISL + OSL (with ``random_range_ratio``) must fit.
+   * - ``params.num_prompts``
+     - ``1000``
+     - Prompt count for ``vllm bench serve``.
+   * - ``params.client_poll_count`` / ``client_poll_wait_time``
+     - ``50`` / ``60``
+     - Client completion poll budget.
+   * - ``params.bench_max_failed_requests``
+     - ``0``
+     - After the bench summary, fail when ``Failed requests`` exceeds this cap.
+   * - ``sweep.sequence_combinations``
+     - named ``isl`` / ``osl`` pairs
+     - Named combos referenced by ``sweep.runs``.
+   * - ``sweep.runs``
+     - ``{combo, concurrency}``
+     - Explicit list of cells to run (not a cartesian product).
+
+Legacy monolithic JSON (``config`` + ``benchmark_params``) is no longer supported by ``inferencemax_single``.
\ No newline at end of file
diff --git a/plans/building-a-cvs-test-suite.md b/plans/building-a-cvs-test-suite.md
new file mode 100644
index 00000000..4da00808
--- /dev/null
+++ b/plans/building-a-cvs-test-suite.md
@@ -0,0 +1,270 @@
+**Building a CVS test suite — a reference guide**
+
+This guide documents the base infrastructure for writing a new **inference** or
+**training** test suite in CVS, using the `vllm_single` suite (PR against
+`dev/dtni`) as the worked reference implementation. If you are adding a serving
+framework, a training benchmark, or any new workload, base your structure on the
+patterns here rather than on the older `InferenceBaseJob` / `if_dict` style.
+
+> **Status note.** CVS is experimental. Flags and config keys change, and the
+> built-in pass/fail is not a trustworthy oracle on its own — always verify a
+> run's artifacts independently. This guide describes the structure, not a frozen
+> API.
+
+> **Training is not ported yet.** Only `vllm_single` (inference) exists today.
+> The library layout, the generic↔domain seam, and the suite skeleton below are
+> deliberately framework-neutral so a training suite drops into the same shape —
+> this guide is the blueprint for that port, not a record of it.
+
+### What changed in the restructure
+
+This PR reorganizes where shared vs. workload-specific code lives, so the next
+suite reuses machinery instead of copy-pasting it.
+
+**`cvs/lib/dtni` → `cvs/lib/utils` (renamed).** `dtni` was a leftover project
+codename; the directory actually holds pure, framework-agnostic helpers. The new
+name says what it is: utilities any suite (inference, training, …) can call.
+
+**`cvs/lib/utils/` — the shared/common layer.** Everything here is generic: no
+suite knows about vLLM, Megatron, ISL/OSL, or goodput. It holds:
+- `config_loader.py` — the generic config skeleton (`BaseVariantConfig`), the
+  `paths`/`model`/`image`/`container` schema, the 3-pass placeholder
+  substitution engine, and `substitute_config()` (read a config + its sibling
+  threshold file, resolve placeholders).
+- `verdict.py` — `evaluate_all(actuals, thresholds)`, a metric-name-agnostic
+  threshold checker (`min`, `max_ms`, `within`, `min_tok_s`, `min_ratio`).
+
+**`cvs/lib/inference/utils/` — the domain-specific layer.** Helpers only an
+*inference* suite needs live here, one level down from the shared dir. It holds:
+- `inferencing_config_loader.py` — the inference config schema: the named-combo
+  sweep selector, `GoodputSlo`, the vLLM bench `Params`, and
+  `VariantConfig(BaseVariantConfig)` with the ISL/OSL/TP/CONC `cell_key`. It
+  *imports* `BaseVariantConfig` + `substitute_config` from `cvs/lib/utils` rather
+  than re-implementing them.
+- `vllm_parsing.py` — the `client.*` metric vocabulary (`to_client_metrics`,
+  `CLIENT_METRICS`): pure transforms from a vLLM benchmark artifact to a
+  namespaced metric dict.
+
+**The rule for where a helper goes.** If every workload could use it (config
+plumbing, threshold math) → `cvs/lib/utils/`. If it only makes sense for one
+domain (sweep shapes, serving metrics) → `cvs/lib/<domain>/utils/`. A training
+port adds `cvs/lib/training/utils/` the same way inference did — subclass
+`BaseVariantConfig`, reuse `substitute_config` and `evaluate_all`, add its own
+schema and metric vocabulary. The shared layer never grows a dependency on a
+specific framework.
+
+```
+cvs/lib/
+  utils/                         # shared, framework-agnostic (was: dtni)
+    config_loader.py             #   BaseVariantConfig, substitute_config, placeholders
+    verdict.py                   #   evaluate_all (generic threshold kinds)
+  inference/
+    utils/                       # inference-only helpers
+      inferencing_config_loader.py   #   sweep selector, Params, VariantConfig, cell_key
+      vllm_parsing.py            #   client.* metrics, to_client_metrics
+    vllm_orch.py                 #   the driver (VllmJob)
+  training/                      # (future) same shape:
+    utils/                       #   training_config_loader.py, <metric>_parsing.py
+```
+
+### The layered architecture
+
+A suite is built from six layers. Each has one job; the seams between them are
+the reusable surface a second suite plugs into.
+
+```
+  cluster file (node IP + user/key/orchestrator)   <- per-environment, OUT of repo
+        |
+  variant config (*_config.json + *threshold.json) <- per-workload, IN repo
+        |
+  config loader  ── cvs/lib/utils/config_loader.py                  (generic: schema, substitution)
+        |          └ cvs/lib/inference/utils/inferencing_config_loader.py (domain schema + sweep)
+        |
+  orchestrator   ── cvs/core/orchestrators (ContainerOrchestrator; provided)
+        |
+  job / driver   ── cvs/lib/inference/vllm_orch.py   (launch server, run client, fetch artifact)
+        |
+  suite / pytest ── cvs/tests/inference/vllm/        (lifecycle-as-tests, parametrization, HTML)
+        |
+  parsing + verdict ── vllm_parsing.to_client_metrics + cvs/lib/utils/verdict.evaluate_all
+```
+
+The **generic↔domain seam** is the key idea: anything every workload shares lives
+in `cvs/lib/utils/`; anything specific to *your* workload lives in your own
+`cvs/lib/<domain>/utils/` module that subclasses/reuses it. The config loader
+docstring literally calls this the "generalization seam," and this PR executes
+the split.
+
+### The two config files (per workload)
+
+A workload is described by a pair of JSON files in the same directory:
+
+- `*_config.json` — the variant: paths, model, container (with `container.image`),
+  params, sweep.
+- `*threshold.json` — the per-cell pass/fail thresholds.
+
+The loader finds the threshold by **sibling glob** (exactly one `*threshold.json`
+next to the config), so the two share a descriptive prefix
+(`llama31_70b_fp8_config.json` / `llama31_70b_fp8_threshold.json`).
+
+#### Placeholders
+
+Config values use `{...}` placeholders resolved in three passes:
+`{user-id}` (from the cluster file) → `{shared_fs}` (self-reference within
+`paths`) → `{paths.models_dir}` (cross-block). An unknown placeholder is left
+literal — there is no error, so check for a stray brace in a resolved path if
+something doesn't mount.
+
+#### enforce_thresholds
+
+`enforce_thresholds: false` makes the suite **record-only**: it captures every
+metric and skips assertions, and a threshold/sweep mismatch warns instead of
+failing the load. Use it for un-calibrated workloads (e.g. throughput
+characterization where the published numbers are curves, not tabulated cells).
+Flip to `true` once you have real numbers — the coverage check then guarantees
+both that every sweep cell has a threshold entry AND that every cell carries a
+spec for every gated metric (`GATED_METRICS`), so a green run can't have
+silently skipped its verdict.
+
+### The sweep selector (named combos + runs)
+
+The sweep enumerates exactly the `(sequence-shape, concurrency)` cells to run. It
+replaces the old `sequence_combinations × concurrency_levels` cartesian:
+
+```json
+"sweep": {
+  "sequence_combinations": [
+    { "name": "w1_isl=128_osl=2048", "isl": "128", "osl": "2048",
+      "goodput_slo": { "ttft_ms": 1000000000.0, "tpot_ms": 1000000000.0, "e2el_ms": 1000000000.0 } }
+  ],
+  "runs": [
+    { "combo": "w1_isl=128_osl=2048", "concurrency": 16 }
+  ]
+}
+```
+
+- Combos are named once; `runs` cherry-picks `(combo, concurrency)` pairs. No NxM
+  explosion — you list precisely the cells you want.
+- Load-time validation rejects duplicate combo names and any `run.combo` that
+  names no combo. (This is mirrored in the suite's `pytest_generate_tests`, which
+  reads raw JSON at collection time before the typed loader runs.)
+- `goodput_slo` is an **input** to the run (passed to `vllm bench serve
+  --goodput`), not a threshold — that's why it lives in the sweep.
+
+Each cell's threshold key is produced by `VariantConfig.cell_key()`
+(`ISL=…,OSL=…,TP=…,CONC=…`). It is the single source of truth shared by the
+coverage check and the verdict lookup, so threshold.json keys must match it
+exactly.
+
+### The job/driver (self-contained, no external .sh)
+
+`vllm_orch.VllmJob` is the reference driver. It talks only to an injected
+orchestrator (`orch.exec`, which routes into the running container) and a typed
+`VariantConfig`. Lifecycle highlights to copy:
+
+- **The server command is built in Python** (`_server_argv`), not cloned from an
+  external `.sh` repo. A run is self-contained. Per-model quirks come from
+  `roles.server.serve_args` (a `{flag: value}` map) / `roles.server.env` in
+  config.
+- **`/tmp/server_env_script.sh`** is written by `build_server_cmd` and **sourced
+  by both server and client**, so the two share one environment (HF token, cache
+  pin, AITER flags). Each value is `shlex.quote`d.
+- **`--max-model-len` is derived per cell** from isl/osl/random_range_ratio so a
+  sweep change stays self-consistent.
+- **Readiness/completion are detected by scanning the whole log**, with narrow
+  failure markers (don't match bare `error:` — ROCm/vLLM logs benign ones).
+- **Results come from the stock `results` artifact**, not console-regex.
+  `parse_results` fetches the extensionless JSON `vllm bench serve` writes to
+  `--result-dir` and hands it to the pure `to_client_metrics`. Missing/empty/
+  unparseable → hard-fail the cell (never a silently-green empty row).
+
+The fetch lives in the job (artifact layout is job-specific); the transform lives
+in `inference/utils` (so distributed/disagg/InferenceMax reuse it).
+
+### The suite (lifecycle-as-tests)
+
+In `cvs/tests/inference/vllm/`, each lifecycle stage is its own pytest test so it
+shows up as a timed, pass/fail row in the HTML report:
+
+```
+test_launch_container → test_setup_sshd → test_model_fetch
+  → test_vllm_inference (per cell) → test_metric (per metric per cell)
+  → test_print_results_table → test_teardown
+```
+
+Patterns to copy:
+
+- **`pytest_generate_tests`** (in the suite module, not conftest) parametrizes
+  from the sweep selector. It runs at collection time and reads raw JSON, so it
+  re-validates combos by hand (mirroring the typed loader).
+- **`test_vllm_inference` runs the benchmark once per cell** and stashes results
+  in a module-scoped `inf_res_dict`. **`test_metric` reads one cached metric** and
+  is one HTML row per metric per cell — no GPU work, asserts only when
+  `enforce_thresholds` is true and a spec exists.
+- **`_Lifecycle`** (`conftest`) carries cross-test state: `failed` lets a broken
+  stage skip the rest instead of cascading; `torn_down` lets explicit teardown
+  suppress the fixture leak-guard finalizer.
+- **The `orch` fixture owns only the teardown safety net** — launch/sshd happen
+  in tests so they're timed rows. A mid-sweep failure still tears the container
+  down via the finalizer.
+- **Single-node guards**: `test_setup_sshd` only probes port 2224 when
+  `len(orch.hosts) > 1` (in-container sshd exists only for inter-node MPI).
+- **HTML Value/Unit columns** come from `pytest_html_results_table_header` /
+  `_row` hooks scoped to this conftest, populated from
+  `metric_value`/`metric_unit` user-properties.
+
+### Parsing + verdict
+
+- **`to_client_metrics(raw, *, tp, isl)`** — pure: stock keys namespaced
+  `client.*` 1:1, plus derived metrics (`per_gpu_throughput`,
+  `decode_throughput_p50`, `success_rate`, …) via `_safe_div` (degrades to
+  `None`, never crashes). `CLIENT_METRICS` is the ordered display surface.
+- **`evaluate_all(actuals, thresholds)`** — generic, framework-neutral. Kinds:
+  `min`, `max`, `max_ms`, `within`, `min_tok_s`, `min_ratio`. Raises
+  `ThresholdViolation` listing every failure. A `None` actual is a loud
+  violation, not a TypeError.
+- **`GATED_METRICS`** (in `vllm_parsing`) — the asserted SLO subset of
+  `CLIENT_METRICS`. The loader's coverage check requires a threshold spec for
+  every gated metric in every present cell, so a gated metric can't silently
+  fall through to a zero-assertion record-only row. A new metric is record-only
+  until added to the set.
+
+### To add your own suite — checklist
+
+1. **Schema.** If serving: reuse `inferencing_config_loader` (subclass `Params`
+   for a new framework's flags). If a new domain (training): create
+   `cvs/lib/<domain>/utils/<domain>_config_loader.py`, subclass
+   `BaseVariantConfig`, reuse `substitute_config` + `evaluate_all` from
+   `cvs/lib/utils/`. Define your own `cell_key` + coverage check.
+2. **Config pair.** Write `*_config.json` + `*threshold.json` under
+   `cvs/input/config_file/<domain>/<suite>/<variant>/`. Start
+   `enforce_thresholds: false` until calibrated.
+3. **Driver.** Write a `Job` class that takes an `orch` + typed config and owns
+   launch → run → fetch-artifact → `parse`. Build commands in Python; keep the
+   pure transform in your `utils`. Hard-fail on missing artifacts.
+4. **Suite.** Under `cvs/tests/<domain>/<suite>/`: `conftest.py` (fixtures +
+   lifecycle + HTML hooks), the suite module (`pytest_generate_tests` +
+   lifecycle-as-tests), `_shared.py` (the results table). Pin test order in
+   `pytest_collection_modifyitems`.
+5. **Metrics.** Define your metric vocabulary + units list once in your `utils`,
+   the way `CLIENT_METRICS` does — don't re-list rows per suite.
+6. **Cluster file.** Keep it minimal and OUT of the repo: node IP + user + key +
+   orchestrator. The variant config supplies the container block; don't ship a
+   bespoke per-suite cluster file.
+7. **Verify independently.** After a run, read the artifact + the HTML cells
+   yourself. CVS's PASS is not a trustworthy oracle.
+
+### Reference files (this PR)
+
+| Layer | File |
+|---|---|
+| generic schema + substitution | `cvs/lib/utils/config_loader.py` |
+| generic verdict | `cvs/lib/utils/verdict.py` |
+| inference schema + sweep | `cvs/lib/inference/utils/inferencing_config_loader.py` |
+| client metric vocabulary | `cvs/lib/inference/utils/vllm_parsing.py` |
+| driver | `cvs/lib/inference/vllm_orch.py` |
+| suite | `cvs/tests/inference/vllm/{vllm_single,conftest,_shared}.py` |
+| config pair | `cvs/input/config_file/inference/vllm_single/w1_llama31_70b_fp8kv/` |
+
+Agent-facing summaries (entry points + gotchas) live in each package's
+`AGENTS.md`.
diff --git a/plans/dtni-dev-guide.md b/plans/dtni-dev-guide.md
index 88935bf7..7020734a 100644
--- a/plans/dtni-dev-guide.md
+++ b/plans/dtni-dev-guide.md
@@ -1,5 +1,16 @@
 # DTNI suite developer guide
 
+> **⚠️ SUPERSEDED — design doc, not current state.** This guide predates the
+> restructure that shipped. It still references the old `cvs/lib/dtni/` and
+> `cvs/input/dtni/` paths (now `cvs/lib/utils/` + `cvs/lib/inference/utils/`),
+> the `concurrency_levels × sequence_combinations` cartesian (now named combos +
+> a `runs[]` selector), the top-level `image` block (now `container.image`),
+> `OrchestratorConfig.from_dicts` / `container.enabled|launch`, and other
+> pre-merge shapes. For the as-built architecture, read
+> `plans/building-a-cvs-test-suite.md` and each package's `AGENTS.md`. Kept for
+> the design rationale (the §5–§7 *why* behind the seam, the Job split, and the
+> config/threshold split), which is still accurate.
+
 ## 1. Intro and scope
 
 This guide is for CVS developers who already run `cvs run` regularly and have edited a test wrapper or a lib helper, but who haven't worked under the new DTNI (data-center training and inference) layout. The goal is to give you the mental model and the concrete skeleton needed to port an existing suite or author a new one.
@@ -58,7 +69,7 @@ flowchart TD
 
 Phase-by-phase:
 
-1. **Load.** `cvs/lib/dtni/config_loader.py` reads `cvs/input/dtni/<suite>/<variant>/config.json` and `threshold.json`, validates through Pydantic models (`extra="forbid"` everywhere except the runtime args passthrough), runs placeholder substitution in fixed order (cluster → self-reference → cross-block), and returns typed objects. One wrapper per suite, parametrized across all variant directories.
+1. **Load.** Generic substitution and threshold discovery live in `cvs/lib/utils/config_loader.py` (`substitute_config`). Per-suite typed loaders validate the result — for example `cvs/lib/inference/utils/inferencing_config_loader.py` (vLLM) or `cvs/lib/inference/utils/inferencemax_config_loader.py` (InferenceMax). Variant configs live under `cvs/input/config_file/inference/<suite>/<variant>/` with a sibling `*threshold.json`. One wrapper per suite, parametrized across variant directories.
 2. **Setup.** A pytest fixture builds an `OrchestratorConfig` (`cvs/core/orchestrators/factory.py`) from the loaded config and yields an `orch`. The fixture calls `orch.setup_containers()` on entry and `orch.teardown_containers()` on exit. No `test_cleanup_stale_containers` or `test_launch_*_containers` in suite code — those concerns are gone.
 3. **Generated tests.** `pytest_generate_tests` (in the suite's `conftest.py`) reads sweep dimensions from the typed config — `benchmark_params.concurrency_levels × sequence_combinations` for inference, `model_params` presets for training — and parametrizes the workload test. Each parametrize cell constructs a Job, calls its verbs, gets back a flat `actuals` dict, and runs `evaluate_all(actuals, thresholds)`.
 4. **Custom tests.** Suite-specific assertions that aren't part of the sweep grid: firewall disable, NIC setup probe, results-table printer, smoke checks. These live in the wrapper as plain `def test_*` functions and use `orch.exec`/`orch.exec_on_head` to talk to the cluster — never `phdl.exec` or `docker_lib` directly.
@@ -74,8 +85,8 @@ This is the base layout. Copy and replace the framework-specific bits.
 """<suite> — DTNI layout. Phases: load → setup → generated → custom."""
 
 import pytest
-from cvs.lib.dtni.config_loader import load_variant, enumerate_variants
-from cvs.lib.dtni.verdict import evaluate_all
+from cvs.lib.inference.utils.inferencing_config_loader import load_variant
+from cvs.lib.utils.verdict import evaluate_all
 from cvs.lib.<domain>.<framework>_orch import <Framework>Job
 
 
@@ -123,13 +134,14 @@ And the conftest that backs it:
 ```python
 # cvs/tests/<domain>/<framework>/conftest.py
 import pytest
-from cvs.lib.dtni.config_loader import load_variant, enumerate_variants
+from cvs.lib.inference.utils.inferencing_config_loader import load_variant
 from cvs.core.orchestrators.factory import OrchestratorConfig, build_orchestrator
 
 def pytest_generate_tests(metafunc):
     if "variant_config" in metafunc.fixturenames:
-        variants = enumerate_variants("cvs/input/dtni/<suite>")
-        metafunc.parametrize("variant_config", variants, ids=[v.id for v in variants], indirect=True)
+        # Most suites pass a single --config_file; multi-variant wrappers may
+        # glob cvs/input/config_file/<domain>/<suite>/<variant>/*_config.json.
+        ...
     if "cell" in metafunc.fixturenames:
         # Cross-product of sweep dims from the already-resolved variant_config.
         ...
diff --git a/plans/vllm-single-orch-poc.md b/plans/vllm-single-orch-poc.md
deleted file mode 100644
index 068bd573..00000000
--- a/plans/vllm-single-orch-poc.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# PoC: vllm_single refactor (orch + typed configs)
-
-Branch: `dev/dtni`. Worktree: `/data/atnair/repos/cvs_worktrees/cvs-dtni/`.
-
-Replace 4 byte-similar `vllm_single` wrappers with one parametrized wrapper, per-variant config + threshold dirs, a typed config loader, and a new orch-driven VllmJob. Container lifecycle moves entirely to `ContainerOrchestrator` (`launch: true`). Existing `cvs/lib/inference/{base,vllm,inference_max}.py` untouched (other suites still use them).
-
-## Approach
-
-- Add `cvs/lib/dtni/__init__.py`, `cvs/lib/dtni/verdict.py` (~60 LOC; 5 kinds: `min`, `max_ms`, `within`, `min_tok_s`, `min_ratio`; `evaluate_all(actuals, thresholds)`).
-- Add `cvs/lib/dtni/config_loader.py` (~110 LOC). Pydantic models with `extra="forbid"`: top-level `schema_version: Literal[1]`, `framework: Literal["vllm_single"]`, `gpu_arch`, `paths` (5 required keys), `model {id, remote: Literal[0,1], precision}`, `image {tag, remote}`, `container` (passthrough shape matching `cvs/core/orchestrators/factory.OrchestratorConfig` — `enabled`, `launch`, `name`, `runtime {name, args}`; `runtime.args` is `extra="allow"`), `roles.server`, `params`, `benchmark_params`, `sweep`. `load_variant(config_path, cluster_dict) -> VariantConfig` loads `config.json` + sibling `threshold.json`, runs 3-pass placeholder substitution: cluster (`{user-id}`) → self-ref (`{shared_fs}` in `paths.*`) → cross-block (`{paths.models_dir}` in `container.runtime.args.volumes`). `model.remote=1` raises `NotImplementedError` pointing at cvs-dtni-v1 `resource_resolver.py`. `enumerate_variants(root_dir) -> list[Path]` walks `cvs/input/dtni/vllm_single/*/`.
-- Add `cvs/lib/inference/vllm_orch.py` (~250 LOC). Standalone `VllmJob` — does NOT inherit `InferenceBaseJob`. Takes `orch: ContainerOrchestrator`. Methods: `build_server_cmd`, `start_server`, `is_ready`, `wait_ready`, `run_client`, `wait_client_complete`, `parse_results`, `stop_server`. All exec via `orch.exec` / `orch.exec_on_head` (orch already routes into the container). Drops: dead distributed branch (`self.port_no`), `random_range_ration` typo, `globals.error_list` indirection, silent-skip in `verify_inference_results`.
-- Add `cvs/tests/inference/vllm/conftest.py` (~70 LOC): `cluster_dict`, `variant_config`, `orch` (constructs `OrchestratorConfig` from cluster_dict identity + `variant_config.container.dict()`; calls `orch.setup_containers()`, yields, calls `orch.teardown_containers()`), `hf_token`, `inf_res_dict` (session-scoped table). `pytest_generate_tests` parametrizes `test_vllm_inference` over `(seq_combo × concurrency)` from the loaded variant.
-- Add `cvs/tests/inference/vllm/_shared.py` (~30 LOC): `test_print_results_table(inf_res_dict)`. `test_cleanup_stale_containers` + `test_launch_inference_containers` collapse into the `orch` fixture lifecycle.
-- Add `cvs/tests/inference/vllm/vllm_single.py` (~60 LOC): `from ._shared import *`. Single `test_vllm_inference(orch, variant_config, hf_token, seq_combo, concurrency, inf_res_dict)` — constructs `VllmJob(orch=orch, ...)`, runs `stop_server → build_server_cmd → start_server → wait_ready → run_client → wait_client_complete → parse_results → evaluate_all(actuals, variant_config.thresholds)`.
-- Add 4 per-variant dirs `cvs/input/dtni/vllm_single/<full-model-name>_perf/{config.json, threshold.json}` for: `Qwen3-Next-80B-A3B-Instruct`, `Qwen3-235B-A22B-Instruct-2507-FP8`, `DeepSeek-V3.1-Terminus`, `gpt-oss-120b`. Each `config.json` carries the existing per-model slice from `mi355x_vllm_single.json` plus the new `paths`/`model`/`image`/`container` blocks. `threshold.json` ports the model's `result_dict` keys.
-- Delete `cvs/tests/inference/vllm/vllm_qwen3_80b_single.py` (480), `vllm_qwen3_235b_single.py` (449), `vllm_deepseek31_685b_single.py` (453), `vllm_gpt_oss_120b_single.py` (451), and `cvs/input/config_file/inference/vllm/mi355x_vllm_single.json` (95).
-
-## Out of scope / Future additions
-
-- Accuracy variants (`*_accuracy/`, `test_vllm_accuracy`, lm_eval harness, dataset download).
-- `cvs/lib/inference/{base,vllm,inference_max}.py` cleanup. Old VllmJob stays; InferenceMaxJob still inherits InferenceBaseJob.
-- Orphan `cvs/lib/inference_lib.py` (`InferenceJobFactory` importing non-existent module) — separate cleanup PR.
-- `model.remote=1` implementation. Schema present, raises NotImplementedError; port from cvs-dtni-v1 `resource_resolver.py` later.
-- `cvs/lib/docker_lib.py` deletion / `cvs/lib/parallel_ssh_lib.py` deprecation cleanup.
-- Switching `cvs/core/*` off the deprecated `parallel_ssh_lib` shim (DeprecationWarning will appear in test output — not blocking).
-- Other suites (sglang, inferencemax, pytorch_xdit, megatron, jax) — untouched.
-- `cvs migrate-config` tool — the 4 variant configs are hand-written.
-- Manifest / sidecar / `cvs export` (v1 W4).
-- Topology / sweep semantics rework (v1 W5).
-- Dev guide (separate doc, written after PoC lands and validates).
-
-## Verification
-
-1. `cd /data/atnair/repos/cvs_worktrees/cvs-dtni && python -m pytest --collect-only cvs/tests/inference/vllm/vllm_single.py --config_file=cvs/input/dtni/vllm_single/Qwen3-Next-80B-A3B-Instruct_perf/config.json --cluster_file=<existing mi355x cluster file>` — expect collection lists `test_vllm_inference[balanced-conc16]` plus `test_print_results_table`. No errors.
-2. `cvs list vllm_single` — expect enumeration of `test_vllm_inference[...]` for all 4 variants (uses default-walk of `cvs/input/dtni/vllm_single/` when `--config_file=dummy`). Plus `test_print_results_table`.
-3. `python -m pytest cvs/tests/inference/vllm/vllm_single.py --config_file=cvs/input/dtni/vllm_single/Qwen3-Next-80B-A3B-Instruct_perf/config.json --cluster_file=<mi355x cluster>` on hardware — expect exit 0. Cell `balanced-conc16` produces a results dict; `test_print_results_table` prints a row matching (within ±10%) the numbers in `vllm_7.14_run.zip / test_print_results_table_*.html`: `Req/s`, `Total tok/s`, `Mean TTFT (ms)`, `Mean TPOT (ms)`, `P99 ITL (ms)`.
-4. During the run, `ssh <mi355x node> docker ps` shows the `vllm_inference_rocm` container appear at `orch.setup_containers()` (not earlier from `docker_lib`) and disappear at `orch.teardown_containers()`. Container is launched by orch, not by VllmJob.
-5. `python -m pytest cvs/tests/inference/vllm/vllm_single.py --config_file=<missing-model-dir>/config.json --cluster_file=...` where `model.remote=0` and `models_dir/<id>` does NOT exist — expect a clean assertion failure naming the missing path, not a runtime crash deep in VllmJob.
-6. `python -c "from cvs.lib.dtni.config_loader import load_variant; load_variant('<config with typo: percentiles_metrics>', {})"` — expect Pydantic `ValidationError` mentioning the unknown field. (Catches the v1 typo class the spec called out.)
-
-## Open questions
-
-1. Cluster file path for verification 1–4 — which existing mi355x cluster file should the PoC default to?
-2. `test_cleanup_stale_containers` + `test_launch_inference_containers` — accept that they vanish from the HTML report (fixture lifecycle replaces them), or keep 5-line stub tests that re-check orch state to preserve the report shape?
-3. New Job class name — `cvs.lib.inference.vllm_orch.VllmJob` (same class name, different module) or `VllmOrchJob` (clearly different during transition)?