@@ -20,6 +20,7 @@
 
 import glob
 import os
+from collections import OrderedDict
 import re
 import threading
 import tomllib
@@ -121,6 +122,12 @@ def __init__(self, backend, chains_dir: str, min_numerals: int = 2, mode: Option
         self.chains = load_chains(chains_dir)
         self.min_numerals = min_numerals
         self._local = threading.local()
+        # Binding and execution read only the state, never the question, so a
+        # multi-question request (17 clauses of one contract) computes its facts
+        # once. Small LRU keyed by state text; entries are immutable tuples.
+        self._facts_cache: "OrderedDict[str, tuple]" = OrderedDict()
+        self._facts_cache_size = int(os.environ.get("VON_CHAINS_CACHE", "64"))
+        self._cache_lock = threading.Lock()
 
     # --- recursion guard: sub-decisions must never re-enter the chain path --
     def active(self) -> bool:
@@ -216,17 +223,18 @@ def _describe(self, chain: Chain, env: Dict[str, Any]) -> Optional[str]:
         except (KeyError, ValueError, IndexError):
             return None
 
-    def _run_bindall(self, state: str, q: Any, tr: Trace) -> Tuple[Optional[Any], Trace]:
-        """No routing. Every chain whose slots bind is executed; computed
-        facts are appended to the state and become spans for the next round
-        (fixpoint, bounded), so chains compose without composed definitions.
-        A chain whose value lands on an option answers through the matcher;
-        the model arbitrates only among grounded survivors, or reads the
-        state plus facts when nothing matched. Nothing reads the question."""
-        instructions = getattr(q, "instructions", "") or ""
+    def _facts_for(self, state: str) -> tuple:
+        """State-only phase of bindall: propose, bind, execute, compose.
+        Returns (facts, execs, trace_fragment); cached per state text."""
+        with self._cache_lock:
+            hit = self._facts_cache.get(state)
+            if hit is not None:
+                self._facts_cache.move_to_end(state)
+                return hit
         facts: List[Tuple[str, str]] = []       # (chain, provenance-carrying description)
+        execs: List[Tuple[str, Any, str]] = []  # (chain, computed value, description) for value chains
+        frag: Dict[str, Dict[str, Any]] = {"route_probs": {}, "bindings": {}, "values": {}}
         seen: set = set()                        # (chain, bindings) already executed
-        matched: Dict[str, Tuple[str, str]] = {}  # option key -> (chain, description)
         base_spans = propose(state)
         derived: List[Span] = []
         self._local.calls = 0
@@ -266,22 +274,43 @@ def _run_bindall(self, state: str, q: Any, tr: Trace) -> Tuple[Optional[Any], Tr
                 prov = f"[{chain.name}: " + ", ".join(f"{k}={v}" for k, v in sub.bindings.items()) + "] "
                 facts.append((chain.name, prov + desc))
                 new_facts += 1
-                tr.route_probs[chain.name] = tr.route_probs.get(chain.name, 0.0) + 1.0
-                tr.bindings.update({f"r{rnd}.{chain.name}.{k}": v for k, v in sub.bindings.items()})
-                tr.values[f"r{rnd}.{chain.name}"] = {k: v for k, v in env.items() if k != "state" and not isinstance(v, Span)}
-                if chain.answer.get("mode") == "value" and isinstance(q, Choice):
-                    val = env.get(chain.answer.get("value", ""))
-                    hit = _match_any(val, q.criteria)
-                    if hit and hit not in matched:
-                        matched[hit] = (chain.name, prov + desc)
+                frag["route_probs"][chain.name] = frag["route_probs"].get(chain.name, 0.0) + 1.0
+                frag["bindings"].update({f"r{rnd}.{chain.name}.{k}": v for k, v in sub.bindings.items()})
+                frag["values"][f"r{rnd}.{chain.name}"] = {k: v for k, v in env.items() if k != "state" and not isinstance(v, Span)}
+                if chain.answer.get("mode") == "value":
+                    execs.append((chain.name, env.get(chain.answer.get("value", "")), prov + desc))
                 if len(facts) >= self.max_facts:
                     break
             if exhausted or new_facts == 0 or len(facts) >= self.max_facts:
                 break
+        out = (tuple(facts), tuple(execs), frag)
+        with self._cache_lock:
+            self._facts_cache[state] = out
+            while len(self._facts_cache) > self._facts_cache_size:
+                self._facts_cache.popitem(last=False)
+        return out
+
+    def _run_bindall(self, state: str, q: Any, tr: Trace) -> Tuple[Optional[Any], Trace]:
+        """No routing. Every chain whose slots bind is executed; computed
+        facts are appended to the state and become spans for the next round
+        (fixpoint, bounded), so chains compose without composed definitions.
+        A chain whose value lands on an option answers through the matcher;
+        the model arbitrates only among grounded survivors, or reads the
+        state plus facts when nothing matched. Nothing reads the question."""
+        instructions = getattr(q, "instructions", "") or ""
+        facts, execs, frag = self._facts_for(state)
+        tr.route_probs.update(frag["route_probs"])
+        tr.bindings.update(frag["bindings"])
+        tr.values.update(frag["values"])
+        matched: Dict[str, Tuple[str, str]] = {}  # option key -> (chain, description)
+        if isinstance(q, Choice):
+            for name, val, desc in execs:
+                hit = _match_any(val, q.criteria)
+                if hit and hit not in matched:
+                    matched[hit] = (name, desc)
         if not facts:
             tr.fallback = "bindall:nothing-executed"
             return None, tr
-
         if isinstance(q, Choice) and len(matched) == 1:
             (hit, (name, desc)), = matched.items()
             tr.chain, tr.description = name, desc
 
@@ -22,6 +22,23 @@ def _stringify_instructions(v: Any) -> Any:
         return json.dumps(v, sort_keys=isinstance(v, dict))
     return v
 
+
+# Option descriptions get the same treatment: the wire format lets a criteria
+# value be any JSON (a chess move as {"uci", "san"}, a palette as a list of hex
+# colours, a number). None stays None (the key stands in for the description).
+def _stringify_criteria(v: Any) -> Any:
+    if not isinstance(v, dict):
+        return v
+    out = {}
+    for k, d in v.items():
+        if d is None or isinstance(d, str):
+            out[k] = d
+        elif isinstance(d, (dict, list)):
+            out[k] = json.dumps(d, sort_keys=isinstance(d, dict))
+        else:
+            out[k] = str(d)
+    return out
+
 class Noul(BaseModel):
     """A yes/no probability question."""
     type: Literal["noul"] = "noul"
@@ -31,7 +48,12 @@ class Noul(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def _fold_legacy_criteria(cls, data: Any) -> Any:
-        if not isinstance(data, dict) or not any(k in data for k in _LEGACY_NOUL_CRITERIA):
+        if not isinstance(data, dict):
+            return data
+        if not any(k in data for k in _LEGACY_NOUL_CRITERIA):
+            if isinstance(data.get("criteria"), dict):
+                data = dict(data)
+                data["criteria"] = _stringify_criteria(data["criteria"])
             return data
         data = dict(data)
         criteria = dict(data.get("criteria") or {})
@@ -49,7 +71,7 @@ def _fold_legacy_criteria(cls, data: Any) -> Any:
             DeprecationWarning,
             stacklevel=2,
         )
-        data["criteria"] = criteria or None
+        data["criteria"] = _stringify_criteria(criteria) or None
         return data
 
     @field_validator("instructions", mode="before")
@@ -69,6 +91,11 @@ class Choice(BaseModel):
     def _coerce_instructions(cls, v: Any) -> Any:
         return _stringify_instructions(v)
 
+    @field_validator("criteria", mode="before")
+    @classmethod
+    def _coerce_criteria(cls, v: Any) -> Any:
+        return _stringify_criteria(v)
+
 
 class Score(BaseModel):
     """A position on an ordered scale (2 to 10 levels)."""
 
@@ -267,3 +267,21 @@ def test_bindall_respects_model_call_budget():
         assert len(r.backend.asked) <= 3  # 2 bind calls + at most one arbitration
     finally:
         del os.environ["VON_CHAINS_MAX_CALLS"]
+
+
+def test_bindall_caches_state_only_phase_across_questions():
+    """A multi-question request binds once: the second question on the same
+    state costs zero bind calls (facts come from the per-state cache), and the
+    answer is identical."""
+    r = _bindall({"start": "2025-03-01", "end": "2025-03-31"})
+    state = "Annual fee is $1,200. Active from 2025-03-01 to 2025-03-31."
+    q1 = Choice(type="choice", instructions="Prorated fee?", criteria={"a": "$101.92", "b": "$100.00"})
+    a1, _ = r.run(state, q1)
+    n_after_first = len(r.backend.asked)
+    assert n_after_first > 0
+    a2, tr2 = r.run(state, Choice(type="choice", instructions="Prorated fee, again?", criteria={"x": "$101.92", "y": "$5"}))
+    assert len(r.backend.asked) == n_after_first  # no new bind calls
+    assert a1.choice == "a" and a2.choice == "x" and tr2.chain == "proration"
+    # a different state is not served from the cache
+    r.run(state.replace("1,200", "2,400"), q1)
+    assert len(r.backend.asked) > n_after_first
@@ -35,3 +35,15 @@ async def test_async_von_client_local():
         },
     )
     assert res.answers["service"].choice == "database"
+
+
+def test_choice_criteria_accepts_structured_descriptions():
+    """Wire format allows any JSON as an option description; Von renders it to text."""
+    from von.types import Choice, Noul
+    c = Choice(instructions="Best move?", criteria={
+        "c8e8": {"uci": "c8e8", "san": "Re8"}, "A": ["#ebf0ff", "#021e61"], "n": 3, "plain": "text", "none": None})
+    assert c.criteria["c8e8"] == '{"san": "Re8", "uci": "c8e8"}'
+    assert c.criteria["A"] == '["#ebf0ff", "#021e61"]'
+    assert c.criteria["n"] == "3" and c.criteria["plain"] == "text" and c.criteria["none"] is None
+    n = Noul(instructions="Hallucinated?", criteria={"true": {"means": "yes"}, "false": "no"})
+    assert n.criteria == {"true": '{"means": "yes"}', "false": "no"}