| name | experience-guided-reasoning-adaptation |
| title | Experience-Guided Adaptation of Inference-Time Reasoning Strategies |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2511.11519 |
| keywords | ["Inference Optimization","Reasoning Strategies","Experience Memory","Adaptive Control","Cost Reduction"] |
| description | Dynamically adapt LLM reasoning strategies at inference time by curating episodic memory of past problem solutions—generate task-specific prompts, tool configs, and control logic for up to 111× cost reduction and 14% accuracy gains. |
Adapt LLM Reasoning Strategies Dynamically Using Past Experience
Most inference-time reasoning optimization fixes prompts and parameters before deployment. Experience-Guided Reasoner (EGuR) treats reasoning strategy as dynamic: it maintains structured memory of past solutions and generates new strategies tailored to each problem's characteristics. Rather than modifying text inputs, EGuR produces complete computational procedures with custom prompts, sampling configs, tool selections, and control flow.
This approach achieves simultaneous improvements in accuracy (up to 14%) and efficiency (up to 111× cost reduction) by matching strategy intensity to problem difficulty—hard problems get more reasoning steps, easy ones get direct inference.
Core Concept
Reasoning strategies span multiple dimensions: textual prompts, sampling parameters (temperature, top-k), tool choices, and control structures (few-shot examples, chain-of-thought depth). Most systems fix all dimensions at deployment time. EGuR instead generates strategies adaptively using two components:
- Guide: An LLM-based meta-reasoner that conditions on the current problem and retrieves relevant past experiences, generating multiple candidate strategies
- Consolidator: Maintains structured memory (successful strategies, general insights) and updates it based on execution feedback
The key insight is that strategy generation is itself learnable and cacheable—successful strategies for similar problems can be retrieved, reducing synthesis cost on the critical path.
Architecture Overview
- Strategy Library: Indexed store of successful strategies with problem signatures for fast retrieval
- General Notes: High-level insights about strategy effectiveness, failure patterns, and tradeoff principles
- Guide Module: LLM that generates k candidate strategies per problem conditioned on current context and retrieved experience
- Compositional Strategy Representation: Formal operations (sequential, parallel, conditional, recursive) enabling adaptation across all strategy dimensions
- Memory Consolidation: Selective retention policies prioritizing recent and reusable experiences
Implementation Steps
Step 1: Memory Structures. Initialize strategy library and notes for experience curation.
class ExperienceMemory:
def __init__(self, max_strategies=):
.strategy_library = {}
.general_notes = []
.max_strategies = max_strategies
.access_count = {}
():
key = problem_sig
key .strategy_library:
.strategy_library[key] = []
entry = {
: strategy,
: success,
: cost,
: accuracy,
: time.time()
}
.strategy_library[key].append(entry)
.access_count[key] = .access_count.get(key, ) +
((v) v .strategy_library.values()) > .max_strategies:
._evict_least_useful()
():
problem_sig .strategy_library:
strategies = .strategy_library[problem_sig]
ranked = (
strategies,
key= x: x[] * ( - x[]/),
reverse=
)
ranked[:k]
[]
