@@ -1,4 +1,3 @@
-import threading
 import time
 from collections.abc import Callable
 from contextlib import contextmanager
@@ -104,10 +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: Max children dispatched in parallel per rlm_query_batched() call.
-                Default 1 = sequential (identical to previous behavior). Set >1 to enable parallel
-                sub-agent execution. A global semaphore (default 16 slots) bounds total concurrent
-                children across all depths to prevent thread/memory explosion.
+            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).
@@ -163,8 +160,6 @@ def __init__(
         self._last_error: str | None = None
         self._best_partial_answer: str | None = None
         self._completion_start_time: float | None = None  # Set when completion() starts
-        # Lock for thread-safe cost/error tracking when children run in parallel
-        self._state_lock = threading.Lock()
 
         # Persistence support
         self.persistent = persistent
@@ -240,15 +235,15 @@ def _spawn_completion_context(self, prompt: str | dict[str, Any]):
             # For local environment with max_depth > 1, pass subcall callback for recursive RLM calls
             if self.environment_type == "local" and self.max_depth > 1:
                 env_kwargs["subcall_fn"] = self._subcall
-                env_kwargs["max_concurrent_subcalls"] = self.max_concurrent_subcalls
             # Pass custom tools to the environment
             if self.custom_tools is not None:
                 env_kwargs["custom_tools"] = self.custom_tools
             if self.custom_sub_tools is not None:
                 env_kwargs["custom_sub_tools"] = self.custom_sub_tools
             if self.compaction and self.environment_type == "local":
                 env_kwargs["compaction"] = True
-            env_kwargs["max_concurrent_subcalls"] = self.max_concurrent_subcalls
+            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:
@@ -318,15 +313,6 @@ def completion(
                     # Check timeout before each iteration
                     self._check_timeout(i, time_start)
 
-                    # Fire iteration start callback
-                    if self.on_iteration_start:
-                        try:
-                            self.on_iteration_start(self.depth, i + 1)
-                        except Exception:
-                            pass
-
-                    iter_start = time.perf_counter()
-
                     # Compaction: check if context needs summarization
                     if self.compaction and hasattr(environment, "append_compaction_entry"):
                         current_tokens, threshold_tokens, max_tokens = self._get_compaction_status(
@@ -390,13 +376,6 @@ def completion(
                     # Verbose output for this iteration
                     self.verbose.print_iteration(iteration, i + 1)
 
-                    # Fire iteration complete callback
-                    if self.on_iteration_complete:
-                        try:
-                            self.on_iteration_complete(self.depth, i + 1, time.perf_counter() - iter_start)
-                        except Exception:
-                            pass
-
                     if final_answer is not None:
                         time_end = time.perf_counter()
                         usage = lm_handler.get_usage_summary()
@@ -728,11 +707,9 @@ def _subcall(self, prompt: str, model: str | None = None) -> RLMChatCompletion:
                 )
 
         # Calculate remaining budget for child (if budget tracking enabled)
-        # Read _cumulative_cost under lock for thread-safe snapshot
         remaining_budget = None
         if self.max_budget is not None:
-            with self._state_lock:
-                remaining_budget = self.max_budget - self._cumulative_cost
+            remaining_budget = self.max_budget - self._cumulative_cost
             if remaining_budget <= 0:
                 return RLMChatCompletion(
                     root_model=resolved_model,
@@ -799,20 +776,16 @@ def _subcall(self, prompt: str, model: str | None = None) -> RLMChatCompletion:
             # Propagate callbacks to children for nested tracking
             on_subcall_start=self.on_subcall_start,
             on_subcall_complete=self.on_subcall_complete,
-            on_iteration_start=self.on_iteration_start,
-            on_iteration_complete=self.on_iteration_complete,
         )
         try:
             result = child.completion(prompt, root_prompt=None)
-            # Thread-safe: track child's cost in parent's cumulative cost
+            # Track child's cost in parent's cumulative cost
             if result.usage_summary and result.usage_summary.total_cost:
-                with self._state_lock:
-                    self._cumulative_cost += result.usage_summary.total_cost
+                self._cumulative_cost += result.usage_summary.total_cost
             return result
         except BudgetExceededError as e:
-            # Thread-safe: propagate child's spending to parent
-            with self._state_lock:
-                self._cumulative_cost += e.spent
+            # Propagate child's spending to parent
+            self._cumulative_cost += e.spent
             error_msg = f"Budget exceeded - {e}"
             return RLMChatCompletion(
                 root_model=resolved_model,
 
@@ -213,7 +213,7 @@ class BaseEnv(ABC):
     """
 
     def __init__(
-        self, persistent: bool = False, depth: int = 1, max_concurrent_subcalls: int = 4, **kwargs
+        self, persistent: bool = False, depth: int = 1, max_concurrent_subcalls: int = 1, **kwargs
     ):
         self.persistent = persistent
         self.depth = depth
 
@@ -22,38 +22,6 @@
     validate_custom_tools,
 )
 
-# =============================================================================
-# Global Subcall Semaphore
-# =============================================================================
-# Bounds the total number of concurrent child RLMs across ALL depths in
-# the process. Each depth level creates its own ThreadPoolExecutor (avoiding
-# pool-within-pool deadlock), but every child must acquire a slot from this
-# semaphore before doing real work. When all slots are taken, new children
-# wait until a running child finishes.
-#
-# Default: 16. Override via set_global_max_subcalls() or pass a custom
-# semaphore to LocalREPL(subcall_semaphore=...).
-
-_DEFAULT_MAX_GLOBAL_SUBCALLS = 16
-_global_subcall_semaphore = threading.Semaphore(_DEFAULT_MAX_GLOBAL_SUBCALLS)
-
-
-
-def set_global_max_subcalls(n: int) -> None:
-    """Replace the global subcall semaphore with a new one of size n.
-
-    Call this BEFORE creating any RLM instances. Not safe to call while
-    subcalls are in flight.
-    """
-    global _global_subcall_semaphore
-    _global_subcall_semaphore = threading.Semaphore(n)
-
-
-def get_global_subcall_semaphore() -> threading.Semaphore:
-    """Return the current global subcall semaphore."""
-    return _global_subcall_semaphore
-
-
 # =============================================================================
 # Safe Builtins
 # =============================================================================
@@ -169,20 +137,13 @@ def __init__(
         custom_sub_tools: dict[str, Any] | None = None,
         compaction: bool = False,
         max_concurrent_subcalls: int = 1,
-        subcall_semaphore: threading.Semaphore | None = None,
         **kwargs,
     ):
-        super().__init__(
-            persistent=persistent,
-            depth=depth,
-            max_concurrent_subcalls=max_concurrent_subcalls,
-            **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._subcall_semaphore = subcall_semaphore or _global_subcall_semaphore
         self.original_cwd = os.getcwd()
         self.temp_dir = tempfile.mkdtemp(prefix=f"repl_env_{uuid.uuid4()}_")
         self._lock = threading.Lock()
@@ -360,19 +321,11 @@ def _rlm_query(self, prompt: str, model: str | None = None) -> str:
 
     def _rlm_query_batched(self, prompts: list[str], model: str | None = None) -> list[str]:
         """Spawn recursive RLM sub-calls for multiple prompts in parallel.
-        Each prompt gets its own child RLM for deeper thinking.
 
-        Execution modes (controlled by max_concurrent_subcalls):
-          - 1 (default): Sequential execution, identical to previous behavior.
-            Zero overhead — no locks, no thread pool, no semaphore.
-          - >1: Parallel execution via ThreadPoolExecutor. Each child RLM
-            runs in its own thread with its own LMHandler and LocalREPL.
-            A global semaphore bounds total concurrent children across all
-            depths to prevent thread/memory explosion with deep recursion.
-
-        No deadlock risk: each depth level creates its own short-lived
-        ThreadPoolExecutor (no pool-within-pool). The global semaphore does
-        not own threads — workers acquire a slot, do work, release.
+        Each prompt gets its own child RLM for deeper thinking. When multiple
+        prompts are provided and max_concurrent_subcalls > 1, subcalls run
+        concurrently using a thread pool. Results are returned in the same
+        order as input prompts.
 
         Falls back to llm_query_batched if no recursive capability is configured.
 
@@ -396,63 +349,26 @@ def _rlm_query_batched(self, prompts: list[str], model: str | None = None) -> li
             for prompt in prompts:
                 try:
                     completion = self.subcall_fn(prompt, model)
-                    with lock:
-                        completions.append((index, completion))
-                    results[index] = completion.response
+                    self._pending_llm_calls.append(completion)
+                    results.append(completion.response)
                 except Exception as 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)
-
+                    results.append(f"Error: RLM query failed - {e}")
             return results
 
         # Fall back to plain batched LM call if no recursive capability
         return self._llm_query_batched(prompts, model)
 
     def _rlm_query_batched_parallel(self, prompts: list[str], model: str | None = None) -> list[str]:
-        """Execute multiple RLM sub-calls in parallel using ThreadPoolExecutor.
-
-        Each child RLM gets its own thread. Results maintain the original
-        prompt order regardless of which child finishes first.
-
-        Concurrency control (two layers):
-          1. Local ThreadPoolExecutor: bounds children dispatched by THIS REPL
-             (max_concurrent_subcalls). Short-lived — created and destroyed
-             per batch call.
-          2. Global semaphore (_subcall_semaphore): bounds total concurrent
-             children across ALL depths in the process. A worker acquires a
-             slot before calling subcall_fn and releases it after, so the
-             semaphore never blocks the pool itself — only the actual work.
-
-        Thread safety:
-          - Each child RLM is fully isolated (own LMHandler, own LocalREPL).
-          - _pending_llm_calls is protected by _calls_lock for concurrent appends.
-          - subcall_fn (RLM._subcall) is called from worker threads — the parent
-            RLM's _state_lock protects cumulative_cost and error tracking.
-        """
+        """Execute multiple RLM sub-calls in parallel using ThreadPoolExecutor."""
         results: list[str | None] = [None] * len(prompts)
-        sem = self._subcall_semaphore
+        completions: list[tuple[int, RLMChatCompletion]] = []
 
         def _execute_one(idx: int, prompt: str) -> tuple[int, str, RLMChatCompletion | None]:
-            sem.acquire()
             try:
                 completion = self.subcall_fn(prompt, model)
                 return (idx, completion.response, completion)
             except Exception as e:
                 return (idx, f"Error: RLM query failed - {e}", None)
-            finally:
-                sem.release()
 
         max_workers = min(self.max_concurrent_subcalls, len(prompts))
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
@@ -464,8 +380,12 @@ def _execute_one(idx: int, prompt: str) -> tuple[int, str, RLMChatCompletion | N
                 idx, response, completion = future.result()
                 results[idx] = response
                 if completion is not None:
-                    with self._calls_lock:
-                        self._pending_llm_calls.append(completion)
+                    completions.append((idx, completion))
+
+        # Append in prompt order for deterministic metadata
+        completions.sort(key=lambda x: x[0])
+        for _, completion in completions:
+            self._pending_llm_calls.append(completion)
 
         return results