Compact context, still recall: how loomcycle saves 80 percent of your tokens

A long-running agent conversation costs tokens quadratically: every turn re-reads the whole prior transcript, so a 200-turn conversation reads its own history 200 times. Loomcycle's answer is a compact-plus-recall pipeline (RFC CR plus RFC CT) that keeps a run under a bounded token budget while a Recall tool retrieves any span the distillation dropped. Three retention modes stack: append is the baseline (every turn kept, cost O(T squared)); recap (L1) preserves the reasoning trace as prose and evicts the rest of the transcript at each boundary; stateful (L2) carries a JSON-schema-validated state Sigma forward and evicts everything else. A tier-routed context.mode auto picks the mode from the provider that resolved: schema-free recap on a local backend, structured stateful on a frontier API. Providers gained a Local capability to make that a routing fact rather than a guess. A stateful agent can propose the shape its own state should take through emit_state propose_schema; the proposal is inert until an operator adopts it. Every eviction hands its span to two consumers: a run-scoped embedded index the Recall tool queries during the same run (RFC CT P1; free-text query, silently falls back to the agent's durable memory, returns originals verbatim), and (opt-in) the durable memory consolidator that turns the span into a fact for future runs (RFC CT P2 harvest_to_memory; whole-batched extraction, not per-span, because RFC CU Probe 2 measured 0.75 vs 0.00 on coreference-dependent facts). A stateful sub-agent hands its Sigma up to the parent as structured JSON on both single spawn and parallel spawn, so a fan-out that used to be N growing transcripts becomes N compact structured results. Recall auto-grants at every toolset-resolution site (RunOnce, HTTP run path, session-continue, sub-agent spawn, resume) so an operator does not have to remember to add it to the allowlist. Working range on a 200-turn chat: about 0.30 times the tokens at recap; about 0.20 times at stateful on a task-shaped run, which is the 80 percent ceiling. State diagrams for the retention lifecycle, the recall pipeline, and the harvest bridge.