@@ -1,7 +1,7 @@
 import time
 from collections.abc import Callable
 from contextlib import contextmanager
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from rlm.clients import BaseLM, get_client
 from rlm.core.lm_handler import LMHandler
@@ -38,6 +38,9 @@
 from rlm.utils.rlm_utils import filter_sensitive_keys
 from rlm.utils.token_utils import count_tokens, get_context_limit
 
+if TYPE_CHECKING:
+    from rlm.utils.cache import LLMCallCache
+
 
 class RLM:
     """
@@ -70,6 +73,7 @@ def __init__(
         custom_sub_tools: dict[str, Any] | None = None,
         compaction: bool = False,
         compaction_threshold_pct: float = 0.85,
+        cache: "LLMCallCache | None" = None,
         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 +106,9 @@ 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).
+            cache: Optional LLMCallCache for memoizing llm_query calls. When provided, identical prompts
+                will return cached responses instead of making redundant API calls. Useful for recursive
+                workloads with overlapping subproblems (e.g., Fibonacci-like decomposition).
             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).
@@ -133,6 +140,9 @@ def __init__(
         self.compaction = compaction
         self.compaction_threshold_pct = compaction_threshold_pct
 
+        # LLM call cache for memoization
+        self.cache = cache
+
         self.depth = depth
         self.max_depth = max_depth
         self.max_iterations = max_iterations
@@ -238,6 +248,9 @@ 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
+            # Pass cache for LLM call memoization
+            if self.cache is not None and self.environment_type == "local":
+                env_kwargs["cache"] = self.cache
             environment: BaseEnv = get_environment(self.environment_type, env_kwargs)
 
             if self.persistent:
 
@@ -10,7 +10,7 @@
 import uuid
 from collections.abc import Callable
 from contextlib import contextmanager
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from rlm.core.comms_utils import LMRequest, send_lm_request, send_lm_request_batched
 from rlm.core.types import REPLResult, RLMChatCompletion
@@ -21,6 +21,9 @@
     validate_custom_tools,
 )
 
+if TYPE_CHECKING:
+    from rlm.utils.cache import LLMCallCache
+
 # =============================================================================
 # Safe Builtins
 # =============================================================================
@@ -135,12 +138,14 @@ def __init__(
         custom_tools: dict[str, Any] | None = None,
         custom_sub_tools: dict[str, Any] | None = None,
         compaction: bool = False,
+        cache: "LLMCallCache | None" = None,
         **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.cache = cache  # Optional LLM call cache for memoization
         self.original_cwd = os.getcwd()
         self.temp_dir = tempfile.mkdtemp(prefix=f"repl_env_{uuid.uuid4()}_")
         self._lock = threading.Lock()
@@ -242,6 +247,7 @@ def _llm_query(self, prompt: str, model: str | None = None) -> str:
         """Query the LM with a single plain completion (no REPL, no recursion).
 
         This always makes a direct LM call via the handler, regardless of depth.
+        Supports optional caching to avoid redundant API calls.
 
         Args:
             prompt: The prompt to send to the LM.
@@ -250,22 +256,32 @@ def _llm_query(self, prompt: str, model: str | None = None) -> str:
         if not self.lm_handler_address:
             return "Error: No LM handler configured"
 
-        try:
+        # Define the actual API call function
+        def make_api_call() -> str:
             request = LMRequest(prompt=prompt, model=model, depth=self.depth)
             response = send_lm_request(self.lm_handler_address, request)
 
             if not response.success:
-                return f"Error: {response.error}"
+                raise RuntimeError(response.error)
 
             self._pending_llm_calls.append(response.chat_completion)
             return response.chat_completion.response
+
+        try:
+            # Use cache if available
+            if self.cache is not None:
+                result, was_cached = self.cache.get_or_call(prompt, model, make_api_call)
+                return result
+            else:
+                return make_api_call()
         except Exception as e:
             return f"Error: LM query failed - {e}"
 
     def _llm_query_batched(self, prompts: list[str], model: str | None = None) -> list[str]:
         """Query the LM with multiple prompts concurrently (no REPL, no recursion).
 
         This always makes direct LM calls via the handler, regardless of depth.
+        Supports optional caching to avoid redundant API calls.
 
         Args:
             prompts: List of prompts to send to the LM.
@@ -276,20 +292,56 @@ def _llm_query_batched(self, prompts: list[str], model: str | None = None) -> li
         """
         if not self.lm_handler_address:
             return ["Error: No LM handler configured"] * len(prompts)
+
         try:
+            # With caching: check cache first, only send uncached prompts to API
+            if self.cache is not None:
+                results: list[str | None] = [None] * len(prompts)
+                uncached_prompts: list[tuple[int, str]] = []
+
+                # Check cache for each prompt
+                for i, prompt in enumerate(prompts):
+                    cached = self.cache.get(prompt, model)
+                    if cached is not None:
+                        results[i] = cached
+                        self.cache.stats.record_hit()
+                    else:
+                        uncached_prompts.append((i, prompt))
+                        self.cache.stats.record_miss()
+
+                # Make API calls only for uncached prompts
+                if uncached_prompts:
+                    uncached_texts = [p for _, p in uncached_prompts]
+                    responses = send_lm_request_batched(
+                        self.lm_handler_address, uncached_texts, model=model, depth=self.depth
+                    )
+
+                    for (idx, prompt), response in zip(uncached_prompts, responses):
+                        if not response.success:
+                            results[idx] = f"Error: {response.error}"
+                        else:
+                            self._pending_llm_calls.append(response.chat_completion)
+                            result = response.chat_completion.response
+                            results[idx] = result
+                            # Cache the successful response
+                            self.cache.set(prompt, model, result)
+
+                return [r if r is not None else "Error: Unexpected cache failure" for r in results]
+
+            # Without caching: send all prompts directly
             responses = send_lm_request_batched(
                 self.lm_handler_address, prompts, model=model, depth=self.depth
             )
 
-            results = []
+            results_list = []
             for response in responses:
                 if not response.success:
-                    results.append(f"Error: {response.error}")
+                    results_list.append(f"Error: {response.error}")
                 else:
                     self._pending_llm_calls.append(response.chat_completion)
-                    results.append(response.chat_completion.response)
+                    results_list.append(response.chat_completion.response)
 
-            return results
+            return results_list
         except Exception as e:
             return [f"Error: LM query failed - {e}"] * len(prompts)
 
 
@@ -0,0 +1,15 @@
+"""
+RLM Utility modules.
+
+Contains helper utilities for parsing, prompts, exceptions, token counting,
+and LLM call caching.
+"""
+
+from rlm.utils.cache import CacheEntry, CacheStats, LLMCallCache, create_cache
+
+__all__ = [
+    "CacheEntry",
+    "CacheStats", 
+    "LLMCallCache",
+    "create_cache",
+]