Cache good answers by task_id so re-runs skip solved questions

GaiaAgent persists non-empty answers to gaia_cache.json and returns cached results on re-run, saving gateway tokens + time and surviving partial failures. Blanks are never cached so they retry. Cache file git-ignored (ephemeral on HF Spaces).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitignore

@@ -161,3 +161,6 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 .langgraph_api/
+
+# agent answer cache
+gaia_cache.json

gaia_agent/agent.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import json
+import os
 import time
 from concurrent.futures import ThreadPoolExecutor
 from concurrent.futures import TimeoutError as FutureTimeout
@@ -9,18 +11,42 @@ from concurrent.futures import TimeoutError as FutureTimeout
 from gaia_agent.config import get_settings
 from gaia_agent.graph import graph
 
+# Sentinel returned when no answer could be produced; never cached.
+_FAILURE = "Unable to determine an answer."
+
 
 class GaiaAgent:
     """Callable wrapper around the compiled LangGraph graph.
 
     ``app.py`` invokes ``agent(question, task_id)`` per question and submits the
-    returned string for exact-match scoring.
+    returned string for exact-match scoring. Good answers are cached to disk by
+    task_id so a re-run skips already-solved questions (saves gateway tokens/time).
     """
 
     def __init__(self):
         self._graph = graph
         self._settings = get_settings()
-        print("GaiaAgent initialised (LangGraph + Groq).")
+        self._cache_path = self._settings.cache_path
+        self._cache = self._load_cache()
+        print(f"GaiaAgent initialised (LangGraph). Cached answers: {len(self._cache)}.")
+
+    # --- cache helpers ---
+    def _load_cache(self) -> dict[str, str]:
+        try:
+            if os.path.exists(self._cache_path):
+                with open(self._cache_path, encoding="utf-8") as fh:
+                    data = json.load(fh)
+                return {k: v for k, v in data.items() if isinstance(v, str) and v}
+        except Exception as exc:  # noqa: BLE001
+            print(f"[GaiaAgent] cache load failed: {exc}")
+        return {}
+
+    def _save_cache(self) -> None:
+        try:
+            with open(self._cache_path, "w", encoding="utf-8") as fh:
+                json.dump(self._cache, fh, ensure_ascii=False, indent=2)
+        except Exception as exc:  # noqa: BLE001
+            print(f"[GaiaAgent] cache save failed: {exc}")
 
     def _run(self, question: str, task_id: str) -> str:
         result = self._graph.invoke(
@@ -30,13 +56,17 @@ class GaiaAgent:
         return (result.get("final_answer") or "").strip()
 
     def __call__(self, question: str, task_id: str = "") -> str:
-        """Run the graph on one question, bounded by QUESTION_TIMEOUT seconds.
+        """Answer one question (timeout-bounded), using/refreshing the disk cache."""
+        # Cache hit: skip recompute (and gateway tokens) entirely.
+        cached = self._cache.get(task_id)
+        if cached:
+            print(f"[GaiaAgent] task {task_id} cache hit -> {cached!r}")
+            return cached
 
-        A fresh single-worker executor per call means a timed-out question's thread
-        is abandoned (daemon) rather than blocking the next question.
-        """
         start = time.time()
         print(f"[GaiaAgent] task {task_id}: {question[:70]}...")
+        # Fresh single-worker executor per call: a timed-out question's thread is
+        # abandoned (daemon) rather than blocking the next question.
         pool = ThreadPoolExecutor(max_workers=1)
         future = pool.submit(self._run, question, task_id)
         try:
@@ -51,4 +81,9 @@ class GaiaAgent:
         finally:
             pool.shutdown(wait=False)
         print(f"[GaiaAgent] task {task_id} done in {time.time() - start:.0f}s -> {answer!r}")
-        return answer or "Unable to determine an answer."
+
+        if answer:  # cache only real answers so blanks are retried next run
+            self._cache[task_id] = answer
+            self._save_cache()
+            return answer
+        return _FAILURE

gaia_agent/config.py

@@ -53,6 +53,12 @@ class Settings(BaseSettings):
     max_tool_rounds: int = 3
     recursion_limit: int = 40
     question_timeout: int = 500
+    # Disk cache of good answers keyed by task_id; lets a re-run skip solved
+    # questions (saves gateway tokens + time). Ephemeral on HF Spaces.
+    cache_path: str = "gaia_cache.json"
+    # Persisted {task_id: answer} cache so reruns skip already-solved questions
+    # (saves provider tokens). Set to "" to disable.
+    answers_cache_path: str = "answers_cache.json"
 
 
 @lru_cache(maxsize=1)