Route default recursive calls to child backend

Author: vishaltandale00

README.md

@@ -146,6 +146,10 @@ rlm = RLM(
 )
 ```
 
+When `other_backends` is configured, its first client is the default for an
+`rlm_query(prompt)` recursive child as well as a max-depth plain sub-call. Passing
+`model=` to `rlm_query` explicitly overrides that default on the parent backend.
+
 ## Training
 We provide a simple RL training harness for training RLMs used in this repo (specifically the `local` REPL). The implementation uses no sandboxes for simplicity and slots easily your use case, but an ideal setup would use sandboxes for safety. Training logic is isolated to the [`training/`](https://github.com/alexzhang13/rlm/tree/main/training) folder, which exposes `rlm.RLM` as a [`verifiers`](https://github.com/willccbb/verifiers) `Environment` and plugs straight into [`prime-rl`](https://github.com/PrimeIntellect-ai/prime-rl). See the [training README](https://github.com/alexzhang13/rlm/tree/main/training#readme) for the launch command. The harness uses subprocess-isolated local REPL execution (no cloud sandboxes), matching the `local` environment above.
 

rlm/core/rlm.py

@@ -730,21 +730,24 @@ def _subcall(self, prompt: str, model: str | None = None) -> RLMChatCompletion:
         """
         next_depth = self.depth + 1
 
-        # Determine which backend/kwargs to use (model override or parent's default)
+        # Determine which backend/kwargs to use. An explicit model stays on the
+        # parent's backend. Without one, the configured recursive child backend is
+        # the default for both child RLMs and max-depth plain calls.
         if model is not None:
+            child_backend = self.backend
             child_backend_kwargs = (self.backend_kwargs or {}).copy()
             child_backend_kwargs["model_name"] = model
+        elif self.other_backends and self.other_backend_kwargs:
+            child_backend = self.other_backends[0]
+            child_backend_kwargs = self.other_backend_kwargs[0]
         else:
+            child_backend = self.backend
             child_backend_kwargs = self.backend_kwargs
         resolved_model = model or (child_backend_kwargs or {}).get("model_name", "unknown")
 
         # If we'd hit/exceed the cap, do a normal LM completion (no REPL)
         if next_depth >= self.max_depth:
-            # Use other_backend if available, otherwise use main backend
-            if self.other_backends and self.other_backend_kwargs:
-                client = self.client_factory(self.other_backends[0], self.other_backend_kwargs[0])
-            else:
-                client = self.client_factory(self.backend, child_backend_kwargs or {})
+            client = self.client_factory(child_backend, child_backend_kwargs or {})
             root_model = model or client.model_name
             start_time = time.perf_counter()
             try:
@@ -814,7 +817,7 @@ def _subcall(self, prompt: str, model: str | None = None) -> RLMChatCompletion:
 
         # Spawn a child RLM with its own LocalREPL
         child = RLM(
-            backend=self.backend,
+            backend=child_backend,
             backend_kwargs=child_backend_kwargs,
             environment=self.environment_type,
             environment_kwargs=self.environment_kwargs,

tests/test_subcall.py

@@ -81,6 +81,30 @@ def client_factory(backend, backend_kwargs):
         assert result.response == "child answer"
         assert calls == [("openai", {"model_name": "review-model"})]
 
+    def test_recursive_child_defaults_to_configured_other_backend(self):
+        calls = []
+
+        def client_factory(backend, backend_kwargs):
+            calls.append((backend, dict(backend_kwargs)))
+            return MockLM(
+                model_name=backend_kwargs["model_name"],
+                responses=[final("independent child answer")],
+            )
+
+        parent = RLM(
+            backend="owner-runtime",
+            backend_kwargs={"model_name": "content-owner"},
+            other_backends=["review-runtime"],
+            other_backend_kwargs=[{"model_name": "self-assess"}],
+            client_factory=client_factory,
+            max_depth=3,
+        )
+
+        result = parent._subcall("review this")
+
+        assert result.response == "independent child answer"
+        assert calls[0] == ("review-runtime", {"model_name": "self-assess"})
+
     def test_factory_is_used_by_max_depth_plain_lm_fallback(self):
         calls = []