@@ -5,6 +5,7 @@
 
 import unicodedata
 from collections.abc import Mapping
+from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple
 
 from ..common._base_service import _TRACE_PARENT_HEADER, BaseService
@@ -32,6 +33,19 @@
 _FORBIDDEN_RULE_NAME_PARTS = ("/", "\\", "..", "%")
 
 
+@dataclass(frozen=True)
+class _RunTarget:
+    """Where a run goes, settled before anything is sent.
+
+    Exactly one of ``folder_key`` and ``folder_path`` is set: a key ready to
+    send, or a path still to look up.
+    """
+
+    name: str
+    folder_key: Optional[str]
+    folder_path: Optional[str]
+
+
 class BusinessRulesService(FolderContext, BaseService):
     """Service for running UiPath Business Rules.
 
@@ -108,27 +122,19 @@ def run(
                 print(decision.decision_name, decision.outputs)
             ```
         """
-        name, folder_key, folder_path = self._apply_binding(
-            name, folder_key, folder_path
-        )
-        _validate_run_arguments(name, input)
-        resolved_folder_key = self._resolve_folder_key(folder_key, folder_path)
+        target = self._prepare_run(name, input, folder_key, folder_path)
         spec = self._evaluate_spec(
-            name,
+            target.name,
             input,
-            folder_key=resolved_folder_key,
+            folder_key=self._resolve_folder_key(target),
             version=version,
             decision_names=decision_names,
             caller=caller,
         )
-        response = self.request(
-            spec.method,
-            url=spec.endpoint,
-            json=spec.json,
-            headers=_headers_with_trace(spec.headers, trace_context),
-            scoped="tenant",
-        )
-        return _to_run_result(_WireResponse.model_validate(response.json()))
+        # Called here, not in a helper: BaseService names the user agent after
+        # the method that calls request(), which must be the public run().
+        response = self.request(spec.method, **_request_options(spec, trace_context))
+        return _to_run_result(response.json())
 
     async def run_async(
         self,
@@ -165,29 +171,38 @@ async def run_async(
             ValueError: If the request is invalid or a required folder is missing.
             EnrichedException: If the service rejects the request.
         """
-        name, folder_key, folder_path = self._apply_binding(
-            name, folder_key, folder_path
-        )
-        _validate_run_arguments(name, input)
-        resolved_folder_key = await self._resolve_folder_key_async(
-            folder_key, folder_path
-        )
+        target = self._prepare_run(name, input, folder_key, folder_path)
         spec = self._evaluate_spec(
-            name,
+            target.name,
             input,
-            folder_key=resolved_folder_key,
+            folder_key=await self._resolve_folder_key_async(target),
             version=version,
             decision_names=decision_names,
             caller=caller,
         )
         response = await self.request_async(
-            spec.method,
-            url=spec.endpoint,
-            json=spec.json,
-            headers=_headers_with_trace(spec.headers, trace_context),
-            scoped="tenant",
+            spec.method, **_request_options(spec, trace_context)
         )
-        return _to_run_result(_WireResponse.model_validate(response.json()))
+        return _to_run_result(response.json())
+
+    def _prepare_run(
+        self,
+        name: str,
+        input: Dict[str, Any],
+        folder_key: Optional[str],
+        folder_path: Optional[str],
+    ) -> _RunTarget:
+        """Do what run() and run_async() share before the first network call.
+
+        Applies a binding, validates the arguments and picks the folder, so only
+        the folder lookup and the request itself differ between the two.
+        """
+        name, folder_key, folder_path = self._apply_binding(
+            name, folder_key, folder_path
+        )
+        _validate_run_arguments(name, input)
+        selected_key, selected_path = self._select_folder(folder_key, folder_path)
+        return _RunTarget(name=name, folder_key=selected_key, folder_path=selected_path)
 
     @resource_override(resource_type="businessRule")
     def _overridden_resource(
@@ -240,25 +255,21 @@ def _select_folder(
             "folder_path, or set UIPATH_FOLDER_KEY or UIPATH_FOLDER_PATH"
         )
 
-    def _resolve_folder_key(
-        self, folder_key: Optional[str], folder_path: Optional[str]
-    ) -> str:
+    def _resolve_folder_key(self, target: _RunTarget) -> str:
         """Return the key of the folder the rule runs in, looking up a path."""
-        selected_key, selected_path = self._select_folder(folder_key, folder_path)
-        if selected_path:
-            selected_key = self._folders_service.retrieve_folder_key(selected_path)
-        return _require_folder_key(selected_key, selected_path)
+        folder_key = target.folder_key
+        if target.folder_path:
+            folder_key = self._folders_service.retrieve_folder_key(target.folder_path)
+        return _require_folder_key(folder_key, target.folder_path)
 
-    async def _resolve_folder_key_async(
-        self, folder_key: Optional[str], folder_path: Optional[str]
-    ) -> str:
+    async def _resolve_folder_key_async(self, target: _RunTarget) -> str:
         """Asynchronously return the key of the folder the rule runs in."""
-        selected_key, selected_path = self._select_folder(folder_key, folder_path)
-        if selected_path:
-            selected_key = await self._folders_service.retrieve_folder_key_async(
-                selected_path
+        folder_key = target.folder_key
+        if target.folder_path:
+            folder_key = await self._folders_service.retrieve_folder_key_async(
+                target.folder_path
             )
-        return _require_folder_key(selected_key, selected_path)
+        return _require_folder_key(folder_key, target.folder_path)
 
     def _evaluate_spec(
         self,
@@ -288,6 +299,18 @@ def _evaluate_spec(
         )
 
 
+def _request_options(
+    spec: RequestSpec, trace_context: Optional[TraceContext]
+) -> Dict[str, Any]:
+    """Return the request() arguments for a spec, besides its method."""
+    return {
+        "url": spec.endpoint,
+        "json": spec.json,
+        "headers": _headers_with_trace(spec.headers, trace_context),
+        "scoped": "tenant",
+    }
+
+
 def _require_folder_key(folder_key: Optional[str], folder_path: Optional[str]) -> str:
     # A folder path that matches no folder looks up to None.
     if folder_key and folder_key.strip():
@@ -390,7 +413,8 @@ def _overall_status(
     return BusinessRuleStatus.PARTIAL_SUCCESS
 
 
-def _to_run_result(response: _WireResponse) -> BusinessRuleRunResult:
+def _to_run_result(response_body: Any) -> BusinessRuleRunResult:
+    response = _WireResponse.model_validate(response_body)
     # A successful response always carries the input's result; one without it is
     # not an answer to report as an evaluation.
     if response.result is None:
 
@@ -378,6 +378,24 @@ def test_sends_no_explain_or_batch(
         assert "explain" not in body
         assert "inputs" not in body
 
+    async def test_run_async_names_itself_in_the_user_agent(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BusinessRulesService,
+        evaluate_url: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(url=evaluate_url, json=_response())
+
+        await service.run_async(RULE, {}, folder_key=FOLDER_KEY)
+
+        request = httpx_mock.get_request()
+        assert request is not None
+        assert (
+            request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.BusinessRulesService.run_async/{version}"
+        )
+
     async def test_run_async_resolves_folder_path(
         self,
         httpx_mock: HTTPXMock,