@@ -70,6 +70,7 @@ def __init__(
         custom_sub_tools: dict[str, Any] | None = None,
         compaction: bool = False,
         compaction_threshold_pct: float = 0.85,
+        max_concurrent_subcalls: int = 4,
         on_subcall_start: Callable[[int, str, str], None] | None = None,
         on_subcall_complete: Callable[[int, str, float, str | None], None] | None = None,
         on_iteration_start: Callable[[int, int], None] | None = None,
@@ -102,6 +103,8 @@ def __init__(
                 when root context reaches compaction_threshold_pct of the model's context limit.
             compaction_threshold_pct: When compaction is on, trigger summarization when root
                 message token count reaches this fraction of the model context limit (default 0.85).
+            max_concurrent_subcalls: Maximum number of parallel threads for rlm_query_batched subcalls.
+                Each child RLM runs in its own thread. Default 4.
             on_subcall_start: Callback fired when a child RLM starts. Args: (depth, model, prompt_preview).
             on_subcall_complete: Callback fired when a child RLM completes. Args: (depth, model, duration, error_or_none).
             on_iteration_start: Callback fired when an iteration starts. Args: (depth, iteration_num).
@@ -132,6 +135,7 @@ def __init__(
 
         self.compaction = compaction
         self.compaction_threshold_pct = compaction_threshold_pct
+        self.max_concurrent_subcalls = max_concurrent_subcalls
 
         self.depth = depth
         self.max_depth = max_depth
@@ -238,6 +242,8 @@ def _spawn_completion_context(self, prompt: str | dict[str, Any]):
                 env_kwargs["custom_sub_tools"] = self.custom_sub_tools
             if self.compaction and self.environment_type == "local":
                 env_kwargs["compaction"] = True
+            if self.environment_type == "local":
+                env_kwargs["max_concurrent_subcalls"] = self.max_concurrent_subcalls
             environment: BaseEnv = get_environment(self.environment_type, env_kwargs)
 
             if self.persistent:
@@ -765,6 +771,8 @@ def _subcall(self, prompt: str, model: str | None = None) -> RLMChatCompletion:
             # Propagate custom tools to children (sub_tools become the child's tools)
             custom_tools=self.custom_sub_tools,
             custom_sub_tools=self.custom_sub_tools,
+            # Propagate concurrency settings to children
+            max_concurrent_subcalls=self.max_concurrent_subcalls,
             # Propagate callbacks to children for nested tracking
             on_subcall_start=self.on_subcall_start,
             on_subcall_complete=self.on_subcall_complete,
 
@@ -9,6 +9,7 @@
 import time
 import uuid
 from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from contextlib import contextmanager
 from typing import Any
 
@@ -135,12 +136,14 @@ def __init__(
         custom_tools: dict[str, Any] | None = None,
         custom_sub_tools: dict[str, Any] | None = None,
         compaction: bool = False,
+        max_concurrent_subcalls: int = 4,
         **kwargs,
     ):
         super().__init__(persistent=persistent, depth=depth, **kwargs)
 
         self.lm_handler_address = lm_handler_address
         self.subcall_fn = subcall_fn  # Callback for recursive RLM calls (depth > 1 support)
+        self.max_concurrent_subcalls = max_concurrent_subcalls
         self.original_cwd = os.getcwd()
         self.temp_dir = tempfile.mkdtemp(prefix=f"repl_env_{uuid.uuid4()}_")
         self._lock = threading.Lock()
@@ -316,9 +319,13 @@ def _rlm_query(self, prompt: str, model: str | None = None) -> str:
         return self._llm_query(prompt, model)
 
     def _rlm_query_batched(self, prompts: list[str], model: str | None = None) -> list[str]:
-        """Spawn recursive RLM sub-calls for multiple prompts.
+        """Spawn recursive RLM sub-calls for multiple prompts in parallel.
+
+        Each prompt gets its own child RLM for deeper thinking. When multiple
+        prompts are provided, subcalls run concurrently using a thread pool
+        (bounded by max_concurrent_subcalls) since they are independent and
+        I/O-bound. Results are returned in the same order as input prompts.
 
-        Each prompt gets its own child RLM for deeper thinking.
         Falls back to llm_query_batched if no recursive capability is configured.
 
         Args:
@@ -329,14 +336,48 @@ def _rlm_query_batched(self, prompts: list[str], model: str | None = None) -> li
             List of responses in the same order as input prompts.
         """
         if self.subcall_fn is not None:
-            results = []
-            for prompt in prompts:
+            # For 0 or 1 prompts, no need for thread pool overhead
+            if len(prompts) <= 1:
+                results = []
+                for prompt in prompts:
+                    try:
+                        completion = self.subcall_fn(prompt, model)
+                        self._pending_llm_calls.append(completion)
+                        results.append(completion.response)
+                    except Exception as e:
+                        results.append(f"Error: RLM query failed - {e}")
+                return results
+
+            # Parallel execution for multiple prompts
+            max_workers = min(self.max_concurrent_subcalls, len(prompts))
+            # Pre-allocate result slots to preserve ordering
+            results: list[str] = [""] * len(prompts)
+            completions: list[tuple[int, RLMChatCompletion]] = []
+            lock = threading.Lock()
+
+            def _run_subcall(index: int, prompt: str) -> None:
                 try:
                     completion = self.subcall_fn(prompt, model)
-                    self._pending_llm_calls.append(completion)
-                    results.append(completion.response)
+                    with lock:
+                        completions.append((index, completion))
+                    results[index] = completion.response
                 except Exception as e:
-                    results.append(f"Error: RLM query failed - {e}")
+                    results[index] = f"Error: RLM query failed - {e}"
+
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                futures = [
+                    executor.submit(_run_subcall, i, prompt)
+                    for i, prompt in enumerate(prompts)
+                ]
+                # Wait for all futures to complete; exceptions are captured inside _run_subcall
+                for future in as_completed(futures):
+                    future.result()  # Re-raises unexpected executor errors
+
+            # Append completions in original prompt order for deterministic metadata
+            completions.sort(key=lambda x: x[0])
+            for _, completion in completions:
+                self._pending_llm_calls.append(completion)
+
             return results
 
         # Fall back to plain batched LM call if no recursive capability
 
@@ -1,5 +1,7 @@
 """Tests for rlm_query and rlm_query_batched in LocalREPL."""
 
+import threading
+import time
 from unittest.mock import MagicMock
 
 from rlm.core.types import RLMChatCompletion, UsageSummary
@@ -186,6 +188,123 @@ def test_llm_query_batched_ignores_subcall_fn(self):
         repl.cleanup()
 
 
+class TestRlmQueryBatchedParallel:
+    """Tests for parallel execution of rlm_query_batched."""
+
+    def test_batched_runs_in_parallel(self):
+        """Multiple subcalls should execute concurrently, not sequentially."""
+        call_times = {}
+        lock = threading.Lock()
+
+        def slow_subcall(prompt, model):
+            start = time.monotonic()
+            time.sleep(0.2)  # Simulate I/O-bound work
+            end = time.monotonic()
+            with lock:
+                call_times[prompt] = (start, end)
+            return _make_completion(f"answer for {prompt}")
+
+        repl = LocalREPL(subcall_fn=slow_subcall, max_concurrent_subcalls=4)
+        start = time.monotonic()
+        result = repl.execute_code("answers = rlm_query_batched(['q1', 'q2', 'q3', 'q4'])")
+        wall_time = time.monotonic() - start
+
+        assert result.stderr == ""
+        answers = repl.locals["answers"]
+        assert len(answers) == 4
+        assert all("answer for" in a for a in answers)
+
+        # If sequential, 4 × 0.2s = 0.8s minimum. Parallel should be ~0.2s.
+        # Use generous threshold to avoid flakiness.
+        assert wall_time < 0.6, f"Expected parallel execution but took {wall_time:.2f}s"
+        repl.cleanup()
+
+    def test_batched_respects_max_concurrent(self):
+        """Thread pool should not exceed max_concurrent_subcalls."""
+        max_concurrent = 2
+        active_count = []
+        active_lock = threading.Lock()
+        active = [0]
+
+        def tracked_subcall(prompt, model):
+            with active_lock:
+                active[0] += 1
+                active_count.append(active[0])
+            time.sleep(0.1)
+            with active_lock:
+                active[0] -= 1
+            return _make_completion(f"ok {prompt}")
+
+        repl = LocalREPL(subcall_fn=tracked_subcall, max_concurrent_subcalls=max_concurrent)
+        result = repl.execute_code("answers = rlm_query_batched(['a', 'b', 'c', 'd'])")
+        assert result.stderr == ""
+        assert max(active_count) <= max_concurrent
+        repl.cleanup()
+
+    def test_batched_preserves_order_parallel(self):
+        """Results must be in the same order as input prompts even with parallel execution."""
+        import random
+
+        def varying_delay_subcall(prompt, model):
+            time.sleep(random.uniform(0.01, 0.1))
+            return _make_completion(f"result-{prompt}")
+
+        repl = LocalREPL(subcall_fn=varying_delay_subcall, max_concurrent_subcalls=4)
+        result = repl.execute_code("answers = rlm_query_batched(['p0', 'p1', 'p2', 'p3'])")
+        assert result.stderr == ""
+        answers = repl.locals["answers"]
+        assert answers == ["result-p0", "result-p1", "result-p2", "result-p3"]
+        repl.cleanup()
+
+    def test_batched_parallel_partial_failure(self):
+        """Failures in some threads should not affect others."""
+        call_count = [0]
+        lock = threading.Lock()
+
+        def sometimes_fail(prompt, model):
+            with lock:
+                call_count[0] += 1
+            if prompt == "fail_me":
+                raise RuntimeError("intentional failure")
+            time.sleep(0.05)
+            return _make_completion(f"ok-{prompt}")
+
+        repl = LocalREPL(subcall_fn=sometimes_fail, max_concurrent_subcalls=4)
+        result = repl.execute_code("answers = rlm_query_batched(['a', 'fail_me', 'c'])")
+        assert result.stderr == ""
+        answers = repl.locals["answers"]
+        assert answers[0] == "ok-a"
+        assert "Error" in answers[1]
+        assert "intentional failure" in answers[1]
+        assert answers[2] == "ok-c"
+        repl.cleanup()
+
+    def test_batched_pending_calls_ordered(self):
+        """Pending LLM calls should be appended in prompt order for deterministic metadata."""
+        def delayed_subcall(prompt, model):
+            # Reverse delay so later prompts finish first
+            delay = 0.1 if prompt == "first" else 0.01
+            time.sleep(delay)
+            return _make_completion(f"resp-{prompt}")
+
+        repl = LocalREPL(subcall_fn=delayed_subcall, max_concurrent_subcalls=4)
+        result = repl.execute_code("answers = rlm_query_batched(['first', 'second'])")
+        assert result.stderr == ""
+        assert len(result.rlm_calls) == 2
+        assert result.rlm_calls[0].response == "resp-first"
+        assert result.rlm_calls[1].response == "resp-second"
+        repl.cleanup()
+
+    def test_single_prompt_skips_thread_pool(self):
+        """Single prompt should not use ThreadPoolExecutor (no overhead)."""
+        subcall_fn = MagicMock(return_value=_make_completion("solo"))
+        repl = LocalREPL(subcall_fn=subcall_fn, max_concurrent_subcalls=4)
+        result = repl.execute_code("answers = rlm_query_batched(['only'])")
+        assert repl.locals["answers"] == ["solo"]
+        subcall_fn.assert_called_once_with("only", None)
+        repl.cleanup()
+
+
 class TestRlmQueryScaffoldRestoration:
     """Test that rlm_query and rlm_query_batched are restored after overwrite."""