@@ -13,9 +13,19 @@ class BaseLM(ABC):
     does so in a model-agnostic way, so this class provides a base interface for all language models.
     """
 
-    def __init__(self, model_name: str, timeout: float = DEFAULT_TIMEOUT, **kwargs):
+    def __init__(
+        self,
+        model_name: str,
+        timeout: float = DEFAULT_TIMEOUT,
+        sampling_args: dict[str, Any] | None = None,
+        **kwargs,
+    ):
         self.model_name = model_name
         self.timeout = timeout
+        # Sampling args forwarded to the underlying completion API
+        # (e.g. temperature, top_p, max_tokens, seed). Forwarded by
+        # subclasses as **self.sampling_args.
+        self.sampling_args: dict[str, Any] = dict(sampling_args or {})
         self.kwargs = kwargs
 
     @abstractmethod
 
@@ -18,6 +18,19 @@
 DEFAULT_PRIME_INTELLECT_BASE_URL = "https://api.pinference.ai/api/v1/"
 
 
+def _normalize_sampling_args(sampling_args: dict[str, Any]) -> dict[str, Any]:
+    """Match the rename done by verifiers' OpenAIChatCompletionsClient so the
+    same sampling_args dict produces byte-equivalent chat.completions.create
+    calls in both harnesses. ``max_tokens`` is the legacy OpenAI param;
+    vLLM treats ``max_completion_tokens`` differently in its pre-reservation
+    check (legacy is reserved up-front against max_model_len; new is not).
+    """
+    args = dict(sampling_args or {})
+    if "max_tokens" in args:
+        args["max_completion_tokens"] = args.pop("max_tokens")
+    return {k: v for k, v in args.items() if v is not None}
+
+
 class OpenAIClient(BaseLM):
     """
     LM Client for running models with the OpenAI API. Works with vLLM as well.
@@ -32,9 +45,10 @@ def __init__(
         api_key: str | None = None,
         model_name: str | None = None,
         base_url: str | None = None,
+        sampling_args: dict[str, Any] | None = None,
         **kwargs,
     ):
-        super().__init__(model_name=model_name, **kwargs)
+        super().__init__(model_name=model_name, sampling_args=sampling_args, **kwargs)
 
         if api_key is None:
             if base_url == "https://api.openai.com/v1" or base_url is None:
@@ -83,7 +97,8 @@ def completion(self, prompt: str | list[dict[str, Any]], model: str | None = Non
             extra_body["usage"] = {"include": True}
 
         response = self.client.chat.completions.create(
-            model=model, messages=messages, extra_body=extra_body
+            model=model, messages=messages, extra_body=extra_body,
+            **_normalize_sampling_args(self.sampling_args),
         )
         self._track_cost(response, model)
         return response.choices[0].message.content
@@ -107,7 +122,8 @@ async def acompletion(
             extra_body["usage"] = {"include": True}
 
         response = await self.async_client.chat.completions.create(
-            model=model, messages=messages, extra_body=extra_body
+            model=model, messages=messages, extra_body=extra_body,
+            **_normalize_sampling_args(self.sampling_args),
         )
         self._track_cost(response, model)
         return response.choices[0].message.content
 
@@ -74,6 +74,9 @@ def __init__(
         on_subcall_complete: Callable[[int, str, float, str | None], None] | None = None,
         on_iteration_start: Callable[[int, int], None] | None = None,
         on_iteration_complete: Callable[[int, int, float], None] | None = None,
+        sampling_args: dict[str, Any] | None = None,
+        sub_sampling_args: dict[str, Any] | None = None,
+        orchestrator: bool = True,
     ):
         """
         Args:
@@ -109,6 +112,32 @@ def __init__(
             on_iteration_start: Callback fired when an iteration starts. Args: (depth, iteration_num).
             on_iteration_complete: Callback fired when an iteration completes. Args: (depth, iteration_num, duration).
         """
+        # Sampling args plumbed into backend_kwargs / other_backend_kwargs
+        # before the clients are constructed, so they reach the chat-completions
+        # call (e.g. temperature, top_p, max_tokens, seed). ``sampling_args``
+        # applies to the root model (depth=0); ``sub_sampling_args`` to
+        # depth=1 sub-LLM calls. If ``sub_sampling_args`` is set without an
+        # ``other_backends``, we mirror the root backend so depth=1 routes
+        # through a separate client with its own sampling args.
+        if sampling_args is not None:
+            backend_kwargs = dict(backend_kwargs or {})
+            existing = dict(backend_kwargs.get("sampling_args") or {})
+            existing.update(sampling_args)
+            backend_kwargs["sampling_args"] = existing
+        if sub_sampling_args is not None:
+            if other_backends is None:
+                other_backends = [backend]
+                other_backend_kwargs = [dict(backend_kwargs or {})]
+            else:
+                other_backend_kwargs = [
+                    dict(kw or {}) for kw in (other_backend_kwargs or [{}])
+                ]
+            first = dict(other_backend_kwargs[0])
+            existing = dict(first.get("sampling_args") or {})
+            existing.update(sub_sampling_args)
+            first["sampling_args"] = existing
+            other_backend_kwargs[0] = first
+
         # Store config for spawning per-completion
         self.backend = backend
         self.backend_kwargs = backend_kwargs
@@ -144,6 +173,7 @@ def __init__(
         self.max_tokens = max_tokens
         self.max_errors = max_errors
         self.system_prompt = custom_system_prompt if custom_system_prompt else RLM_SYSTEM_PROMPT
+        self.orchestrator = orchestrator
         self.logger = logger
         self.verbose = VerbosePrinter(enabled=verbose)
 
@@ -276,6 +306,7 @@ def _setup_prompt(
             query_metadata=metadata,
             custom_tools=self.custom_tools,
             root_prompt=root_prompt,
+            orchestrator=self.orchestrator,
         )
         if self.compaction:
             message_history[0]["content"] += (