@@ -218,8 +218,14 @@ def aiperf_is_usable() -> bool:
     return result.returncode == 0
 
 
-def post_one_token(url: str, model: str, timeout: float) -> "str | None":
-    """POST a 1-token non-streaming completion. Returns the body, or None on failure."""
+def post_one_token(
+    url: str, model: str, timeout: float, *, fail_on_client_error: bool = False
+) -> "str | None":
+    """POST one token, optionally raising with the reason for a rejected request.
+
+    Transport failures, server errors, and retryable HTTP 408/429 responses
+    return None. Heartbeats also ignore request rejections by default.
+    """
     payload = json.dumps(
         {
             "model": model,
@@ -237,6 +243,15 @@ def post_one_token(url: str, model: str, timeout: float) -> "str | None":
     try:
         with urllib.request.urlopen(req, timeout=timeout) as resp:
             return resp.read().decode(errors="replace")
+    except urllib.error.HTTPError as error:
+        if fail_on_client_error and 400 <= error.code < 500 and error.code not in (408, 429):
+            with error:
+                body = error.read(2048).decode(errors="replace")
+            raise RuntimeError(
+                f"{req.full_url} rejected the 1-token readiness request: HTTP {error.code}: {body}"
+            ) from error
+        error.close()
+        return None
     except (urllib.error.URLError, OSError, TimeoutError):
         return None
 
@@ -300,27 +315,25 @@ def ensure_aiperf(url: str, model: str) -> None:
 def verify_endpoint(url: str, model: str) -> None:
     """Prove the endpoint serves one real token before spending GPU-hours.
 
-    The harness has already waited for the disagg server, so this is a short
-    confirmation rather than the reference script's 5400 s poll. It exists
-    because a broken ctx->gen KV path answers /health perfectly well and only
-    fails once real traffic arrives -- an hour later, as a client-side error.
+    A healthy process may still reject inference requests or fail to generate.
+    This check applies to both aggregated and disaggregated servers. Permanent
+    request errors fail immediately with the response body; transient failures
+    retain the readiness retry budget.
     """
     timeout = _env_int("AGENTX_READY_TIMEOUT", 900)
     interval = _env_int("AGENTX_READY_INTERVAL", 15)
     deadline = time.monotonic() + timeout
     last = None
     while time.monotonic() < deadline:
-        last = post_one_token(url, model, timeout=300)
+        last = post_one_token(url, model, timeout=300, fail_on_client_error=True)
         if last and '"choices"' in last:
-            _log("1-token completion OK -- the disagg path is live")
+            _log("1-token completion OK -- the inference endpoint is ready")
             return
         _log(f"not serving yet (response head: {str(last)[:200]})")
         time.sleep(interval)
     raise RuntimeError(
-        f"{url} could not complete ONE token within {timeout}s. This is a "
-        f"SERVER-side failure: inspect the ctx/gen worker logs and the disagg "
-        f"server log, not the client. Suspect the ctx->gen KV transfer "
-        f"(on GB300/NVL72 check UCX_TLS contains no 'rc'). "
+        f"{url} could not complete ONE token within {timeout}s. "
+        f"Inspect the inference server logs and readiness request failures. "
         f"Last response: {str(last)[:500]}"
     )
 
 
@@ -39,6 +39,7 @@ l0_cpu:
   # catches a pruned reference before the post-merge canary does.
   - model_express/test_model_express_accuracy.py::test_mx_accuracy_cases_have_references
   - unittest/test_s3_output.py
+  - unittest/scripts/test_perf_client_readiness.py
   - unittest/_torch/visual_gen/multi_gpu/test_worker_pool.py
   # Covers tests/unittest/_torch/attention/. Two sub-trees moved in here from elsewhere
   # under tests/unittest/_torch/ and have no entry of their own on any list, so this entry
 
@@ -0,0 +1,111 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Exercise benchmark client readiness against real HTTP rejection and retry responses."""
+
+import importlib.util
+import json
+import threading
+import urllib.error
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+pytestmark = pytest.mark.cpu_only
+
+CLIENT_PATH = Path(__file__).resolve().parents[3] / "tests/integration/defs/perf/agentx_client.py"
+
+
+@pytest.fixture
+def client(monkeypatch: pytest.MonkeyPatch) -> ModuleType:
+    spec = importlib.util.spec_from_file_location("perf_benchmark_client", CLIENT_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    monkeypatch.setenv("AGENTX_READY_TIMEOUT", "60")
+    monkeypatch.setattr(module.time, "sleep", lambda _: None)
+    return module
+
+
+@pytest.fixture
+def endpoint():
+    responses = []
+    requests = []
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self) -> None:
+            requests.append(
+                (self.path, json.loads(self.rfile.read(int(self.headers["Content-Length"]))))
+            )
+            status, body = responses.pop(0) if responses else (503, "not ready")
+            self.send_response(status)
+            self.end_headers()
+            self.wfile.write(body.encode())
+
+        def log_message(self, *args: object) -> None:
+            pass
+
+    server = HTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://127.0.0.1:{server.server_port}", responses, requests
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)
+
+
+@pytest.mark.parametrize("status", [400, 401, 403, 404, 422])
+def test_rejection_preserves_server_reason(client: ModuleType, endpoint, status: int) -> None:
+    url, responses, requests = endpoint
+    responses.append((status, '{"error":{"message":"unsupported chat template"}}'))
+    with pytest.raises(RuntimeError, match=f"HTTP {status}.*unsupported chat template"):
+        client.verify_endpoint(url, "model")
+    assert len(requests) == 1
+    assert requests[0][0] == "/v1/chat/completions"
+    assert requests[0][1]["model"] == "model"
+
+
+@pytest.mark.parametrize("status", [408, 429, 500, 503])
+def test_transient_http_failure_still_retries(client: ModuleType, endpoint, status: int) -> None:
+    url, responses, requests = endpoint
+    responses.extend([(status, "temporarily unavailable"), (200, '{"choices":[{}]}')])
+    client.verify_endpoint(url, "model")
+    assert len(requests) == 2
+
+
+def test_heartbeat_request_remains_best_effort(client: ModuleType, endpoint) -> None:
+    url, responses, requests = endpoint
+    responses.append((400, "invalid request"))
+    assert client.post_one_token(url, "model", timeout=1) is None
+    assert len(requests) == 1
+
+
+def test_transport_failure_remains_retryable(client: ModuleType, monkeypatch) -> None:
+    def unavailable(*args: object, **kwargs: object) -> None:
+        raise urllib.error.URLError("connection refused")
+
+    monkeypatch.setattr(client.urllib.request, "urlopen", unavailable)
+    assert client.post_one_token("http://unused", "model", timeout=1) is None
+
+
+def test_rejection_body_is_bounded(client: ModuleType, endpoint) -> None:
+    url, responses, _ = endpoint
+    responses.append((400, "x" * 10000))
+    with pytest.raises(RuntimeError, match="HTTP 400") as error:
+        client.verify_endpoint(url, "model")
+    assert len(str(error.value)) < 2300