PRECEPT: Planning Resilience via Experience, Context Engineering & Probing Trajectories A Unified Framework for Test-Time Adaptation with Compositional Rule Learning and Pareto-Guided Prompt Evolution

Arash Shahmansoori

cs.AIMar 10, 2026

PRECEPT: Planning Resilience via Experience, Context Engineering & Probing Trajectories A Unified Framework for Test-Time Adaptation with Compositional Rule Learning and Pareto-Guided Prompt Evolution

Authors: Arash Shahmansoori

Abstract

LLM agents that store knowledge as natural language suffer steep retrieval degradation as condition count grows, often struggle to compose learned rules reliably, and typically lack explicit mechanisms to detect stale or adversarial knowledge. We introduce PRECEPT, a unified framework for test-time adaptation with three tightly coupled components: (1) deterministic exact-match rule retrieval over structured condition keys, (2) conflict-aware memory with Bayesian source reliability and threshold-based rule invalidation, and (3) COMPASS, a Pareto-guided prompt-evolution outer loop. Exact retrieval eliminates partial-match interpretation errors on the deterministic path (0% by construction, vs 94.4% under Theorem~B.6's independence model at N=10) and supports compositional stacking through a semantic tier hierarchy; conflict-aware memory resolves static--dynamic disagreements and supports drift adaptation; COMPASS evaluates prompts through the same end-to-end execution pipeline. Results (9--10 seeds): PRECEPT achieves a +41.1pp first-try advantage over Full Reflexion (d>1.9), +33.3pp compositional generalization (d=1.55), 100% $P_1$ on 2-way logistics compositions (d=2.64), +40--55pp continuous learning gains, strong eventual robustness under adversarial static knowledge (100% logistics with adversarial SK active; partial recovery on integration), +55.0pp drift recovery (d=0.95, p=0.031), and 61% fewer steps. Core comparisons are statistically significant, often at p<0.001.

Figures & tables

Panel of Figure 1 — Figure 1: PRECEPT architecture overview. The client handles orchestration, high-frequency monitoring, retrieval-time decision support, and learning updates; the server handles MCP dispatch, conflict-aware retrieval, low-frequency COMPASS evolution, domain execution, and persistent memory. The dashed arrow denotes the evolved prompt flowing from the server-side architect back to the client monitor.

Feature	Code Implementation	Theoretical Foundation	Section
Dual-Mode Retrieval	fetch_context*() + server retrieval tools: retrieve_memories() , get_rule_hybrid() , retrieve_atomic_precepts() ; unified interface: retrieve_with_dual_mode()	Definition 2.2 + retrieval-tier specification (§2.3.1)	§2.3.1
Type I Conflict (Static vs Dynamic)	EnsembleConflictDetector.detect()	Ensemble weight specification + Definition 4.1 + Algorithm 4.1a	§4.1
Evo-Memory	partial_progress , failed_options	Definition 4.0, Theorem 4.0 (Eliminates Cyclic Failures)	§4.0
Deterministic Pruning	RefineInterceptor.is_forbidden() , add_constraint()	Theorem 4.5 (P(repeat_fail)=0), Corollary 4.5.1	§4.5
Thompson Sampling	BetaDistribution.sample()	Definition 4.1, Theorem 4.1 (Local stationary-segment bound)	§4.1
Bayesian Conflict Resolution	BetaDistribution.update(success)	Definition 4.1, Algorithm 4.1a	§4.1

Table 1: Code-to-theory mapping for PRECEPT’s major components.

Panel of Figure 2 — Figure 2: Complete seven-phase execution flow of the PRECEPT agent: (1) Task parsing with hybrid rule+LLM fallback, (2) COMPASS complexity evaluation with block/proceed/fast-path decisions, (3) Three-mode context retrieval (compositional, hybrid, semantic), (4) Solution derivation with tier-sorted priority, (5) Domain action execution, (6) Outcome processing with threshold-based invalidation ( $\theta{=}2$ ), and (7) Knowledge update via atomic precept extraction. Dashed arrow indicates the retry loop.

Panel of Figure 3 — Figure 3: Knowledge Layer with three retrieval modes: exact-match $O(1)$ via dictionary lookup (highest priority), semantic similarity $O(\log n)$ via hybrid BM25+embedding search, and compositional retrieval via atomic precept decomposition with tier-sorted stacking. Conflicts are resolved through Bayesian Thompson sampling respecting the Safety $>$ Compliance $>$ Preferences hierarchy.

Tier	Storage	Source	Confidence Prior	Retrieval	Use Case
Static KB	Vector DB	Pre-deployment (PDFs, docs)	0.9 (high)	Semantic similarity	Factual grounding
Dynamic Experience	Vector DB	Runtime (web, APIs)	0.8 (moderate)	Semantic + metadata filter	Current information
Episodic Memory	MemoryStore	Task executions	Task-dependent	Trajectory matching	Experience replay
Learned Rules	Hash Table	Successful solutions	1.0 (deterministic)	$O(1)$ exact match	Direct application

Table 2: PRECEPT’s four knowledge tiers, their storage backends, priors, and retrieval roles.

Panel of Figure 4 — Figure 4: Complete PRECEPT execution pipeline. Tasks flow through the COMPASS Monitor ( $O(1)$ constraint check), three-mode retrieval (exact-match, semantic, compositional), Bayesian conflict resolution via Thompson sampling, execution with deterministic pruning via RefineInterceptor, and threshold-based rule invalidation ( $\theta{=}2$ ). On success, rules are persisted; on state-change events, the COMPASS Architect (low-frequency loop, dashed teal) triggers prompt evolution and Pareto selection. On failure, the retry loop (dashed red) returns to the Monitor with the failed option pruned.

Stage	Client/Server	MCP Tool / Function	Key Operation
(1) Parse	Client	PRECEPTAgent.run_task()	Parse task; inject condition metadata when available
(2) Retrieve	Client $\rightarrow$ Server	fetch_context*() $\rightarrow$ retrieve_memories() , get_rule_hybrid() , retrieve_atomic_precepts()	Orchestrate retrieval for the reported runtime path
(3) Compose	Client + Server	Tier sorting + constraint-stack construction	Use deterministic highest-tier fast path when directly applicable; otherwise pass stacked constraints to synthesis
(4) Detect	Server	ConflictManager.detect() + atomic-precept conflict checks	Resolve static–dynamic conflicts; compositional retrieval also checks atomic-precept conflicts by default
(5) Execute	Server	Domain tools ( book_shipment , etc.)	Apply selected or synthesized solution via domain-specific tool
(6) Handle	Client $\rightarrow$ Server	report_rule_failure( $\kappa$ ) / record_rule_success( $\kappa$ )	Decay $\times$ 0.5, restore +0.25, invalidate at $\theta$ =2

Table 3: Simplified client–server execution pipeline with MCP tool mapping.

Tier	Priority	Category	Conditions	Dominance Rule
3	Highest	Safety	SAFE, SECURE, RISK, CANCEL, AUTH	Always wins
2	Medium	Compliance	ASIA, EURO, INTL, HIPAA, AUDIT	Wins over Tier 1
1	Lowest	Preferences	FAST, ECON, BULK, SPEED, COST	Default fallback

Table 4: Semantic tier hierarchy used for atomic constraint stacking.

Method	Raw Weight	Normalized Weight	Description
NLI Classifier	0.30	0.200	Natural language inference
Semantic Patterns	0.30	0.200	Keyword contradiction detection
Temporal Analysis	0.15	0.100	Recency-based staleness
Evidence Strength	0.15	0.100	Confirmation/failure counts
Recommendation Conflict	0.50	0.333	Dismissive-vs-active strategy detection
LLM Vote	0.10	0.067	Optional LLM adjudication

Table 5: Six-method ensemble conflict detector weights used for Type I conflict detection.

Parameter	Value	Operation
UNLEARN_FAILURE_THRESHOLD	2	Invalidate after N consecutive failures
Confidence decay ( $\delta$ )	$\times$ 0.5	confidence *= 0.5 per failure
Confidence restore	+0.25	confidence = min(1.0, c + 0.25) on success

Table 6: Rule invalidation hyperparameters used for Type II drift adaptation.

Panel of Figure 5 — Figure 5: Evo-Memory lifecycle for Type II (rule drift) handling. On success, the failure counter resets and confidence increases; on failure, confidence decays by half ( $c\times 0.5$ ) and the failure counter increments. When $f\geq\theta$ ( $\theta{=}2$ by default), the rule is invalidated via record_rule_failure() , triggering re-learning. This yields stale-rule persistence probability $(1{-}d)^{\theta}\leq 0.0025$ for PRECEPT (Corollary 6.7).

Panel of Figure 6 — Figure 6: COMPASS: Complexity-Optimized Multi-strategy Pareto Adaptive Search. (a) End-to-end pipeline from task complexity analysis through Pareto-optimal prompt selection. (b) Pareto selection mechanism: candidates are evaluated on two objectives (success rate, step efficiency); dominated candidates (gray) are filtered, and the winner (orange star) is chosen from the non-dominated Pareto front (blue) by maximum hypervolume contribution. (c) Verified prompt evolution: the agent predicts solutions, the environment verifies internally, and only binary signals drive evolution—no expected solutions are ever exposed to the agent.

Component	Class	Function
Complexity Analyzer	PRECEPTComplexityAnalyzer	Estimates tool/reasoning/retrieval steps via pattern detection
Smart Rollout	SmartRolloutStrategy	Allocates rollouts based on score (0.98 $\rightarrow$ skip, 0.9 $\rightarrow$ verify, else $\rightarrow$ explore)
Pareto Selection	pareto_select()	Selects from non-dominated front by hypervolume contribution

Table 7: COMPASS components and their corresponding implementation classes.

Panel of Figure 7 — Figure 7: COMPASS dual-frequency control loop. The high-frequency monitor runs at every agent step with $O(1)$ cost for real-time constraint checking and pattern learning. When trigger events are emitted (new rule discovered, goal failure, phase change), the low-frequency architect activates for strategic re-planning: context compilation, GEPA-based prompt evolution, Pareto selection of candidates, and MAP-Elites-guided memory pruning.

Domain	Description	$E$ (Unique Keys)	Options	$T_{\text{train}}$ ( $\beta$ =3)
Integration	OAuth failures, API errors	6	15	18
Booking	Reservation failures, overbooking	17	20	51
Logistics	Port closures, customs delays	4	4	12

Table 9: Evaluated domains and their core training-time complexity statistics.

Domain	Options	$E$	$P_{\text{rand}}$	LLM Prior Bias	Primary Difficulty
Logistics	4	4	25%	Low (geographic ports)	Majority-vote trap from component overlap
Integration	2 *	6	50% *	High (brand-name priors)	Adversarial naming + prior override
Booking	2 *	17	50% *	Low (IATA codes)	Largest key space + phantom inventory

Table 10: Benchmark difficulty summary across the three evaluated domains.

Parameter	Value	Description
Compilation candidates	5	Prompt variants generated per compilation cycle
Rollouts per candidate	3	Base rollouts (adjusted by smart strategy)
Acceptance threshold	0.6	Min score to adopt an evolved prompt
Pareto weights	0.7 / 0.3	success_rate / step_efficiency
Evolution interval	2 tasks	Trigger frequency for lo-freq architect
Diversity threshold	0.7	Min diversity to skip diversity rollouts

Table 12: COMPASS hyperparameters used in all reported experiments.

Domain	E	Options	PRECEPT $P_{1}$	FR $P_{1}$	ExpeL $P_{1}$
Integration	6	15	80.0% $\pm$ 12.3	36.7% $\pm$ 7.5	43.3% $\pm$ 8.3
Booking	17	20	94.1% $\pm$ 4.9	51.8% $\pm$ 14.0	90.0% $\pm$ 6.9
Logistics	4	4	95.0% $\pm$ 5.0	57.5% $\pm$ 14.7	90.0% $\pm$ 9.2
Average			89.7%	48.6%	74.4%

Table 13: Experiment 1 first-try success (

P_{1}

) across the three main domains.

Domain	PRECEPT $P_{t}$	FR $P_{t}$	ExpeL $P_{t}$	PRECEPT Steps	FR Steps	ExpeL Steps
Integration	83.3% $\pm$ 11.2	41.7% $\pm$ 6.3	46.7% $\pm$ 5.0	2.72 $\pm$ 0.46	7.83 $\pm$ 0.58	6.43 $\pm$ 0.53
Booking	99.4% $\pm$ 0.6	94.7% $\pm$ 5.3	98.8% $\pm$ 1.2	2.15 $\pm$ 0.12	4.60 $\pm$ 0.86	2.40 $\pm$ 0.29
Logistics	100.0% $\pm$ 0.0	80.0% $\pm$ 11.3	97.5% $\pm$ 2.5	2.10 $\pm$ 0.23	5.25 $\pm$ 0.76	2.45 $\pm$ 0.52
Average	94.2%	72.1%	81.0%	2.32	5.89	3.76

Table 14: Experiment 1 overall success (

P_{t}

) and step efficiency across the three main domains.

Figure 8: Experiment 1 main comparison across the three evaluated domains: first-try success and step efficiency.

Figure 9: Experiment 2 compositional generalization across logistics and integration. PRECEPT reaches 100% $P_{1}$ on 2-way logistics compositions and shows the strongest overall compositional performance.

Domain	Config	PRECEPT $P_{1}$	FR $P_{1}$	ExpeL $P_{1}$	PRECEPT $P_{t}$	FR $P_{t}$	ExpeL $P_{t}$	$d_{P_{1}}$ (vs FR)
Logistics	2-way	100.0% $\pm$ 0.0	57.3% $\pm$ 11.6	47.7% $\pm$ 14.6	100.0% $\pm$ 0.0	97.8% $\pm$ 3.4	96.0% $\pm$ 5.0	2.64 ∗∗∗
Logistics	3-way	78.0% $\pm$ 9.4	43.0% $\pm$ 13.9	40.0% $\pm$ 10.1	99.0% $\pm$ 2.3	97.0% $\pm$ 3.5	93.0% $\pm$ 5.9	1.31 ∗∗
Integration	2-way	41.7% $\pm$ 33.4	18.1% $\pm$ 16.4	11.2% $\pm$ 11.2	53.3% $\pm$ 32.7	32.4% $\pm$ 16.9	42.4% $\pm$ 20.7	0.84 ∗
Integration	3-way	49.0% $\pm$ 25.7	17.0% $\pm$ 11.5	25.0% $\pm$ 21.6	58.3% $\pm$ 30.1	42.0% $\pm$ 24.7	38.7% $\pm$ 23.9	0.90 ∗
Overall		67.2% $\pm$ 24.0	33.9% $\pm$ 18.7	31.0% $\pm$ 20.5	77.7% $\pm$ 22.7	67.3% $\pm$ 16.9	67.5% $\pm$ 19.4	1.55 ∗∗∗

Table 15: Experiment 2 compositional generalization results across logistics and integration.

Figure 10: $P_{1}$ and Avg Steps vs Training Exposure ( $\beta$ effect) across both domains. PRECEPT achieves 100% $P_{1}$ on integration at $\beta{\geq}3$ and 87.5–92.5% on logistics, with near-optimal 2.0-step efficiency.

Domain	$\beta$	$P_{1}$ (%)			Avg Steps			$P_{1}$ : vs FR		$P_{1}$ : vs ExpeL
Domain	$\beta$	PRECEPT	FR	ExpeL	PRECEPT	FR	ExpeL	$d$	$p$	$d$	$p$
Integration	1	63.3	35.0	41.7	3.58	8.13 ∗∗	6.27 ∗	0.44	0.194	0.36	0.282
	2	98.3	45.0	36.7	2.08	7.33 ∗∗∗	6.77 ∗∗∗	5.06 ∗∗∗	${<}$ 0.001	3.19 ∗∗∗	${<}$ 0.001
	3	100.0	38.3	48.3	2.00	7.63 ∗∗∗	6.03 ∗∗∗	3.90 ∗∗∗	${<}$ 0.001	9.80 ∗∗∗	${<}$ 0.001
	4	100.0	43.3	46.7	2.00	7.27 ∗∗∗	6.27 ∗∗∗	4.86 ∗∗∗	${<}$ 0.001	5.06 ∗∗∗	${<}$ 0.001
	5	98.3	46.7	48.3	2.02	7.07 ∗∗∗	6.03 ∗∗∗	5.46 ∗∗∗	${<}$ 0.001	6.36 ∗∗∗	${<}$ 0.001

Table 16: Primary Exp3 results (

N{=}5

, 10 seeds per

\beta

). Bold = best

P_{1}

/Steps. Significance (paired

t

-test):

{}^{*}p{<}0.05

{}^{**}p{<}0.01

{}^{***}p{<}0.001

P_{1}

columns: markers on

d

values. Steps columns: markers on baseline values indicate PRECEPT-vs-baseline step significance.

Figure 11: Experiment 4 continuous learning. PRECEPT improves fastest across repeated encounters, reaching 100% $P_{1}$ by encounter 4 on logistics and 70.4% on integration while maintaining the lowest step count.

Encounter	PRECEPT $P_{1}$	ExpeL $P_{1}$	FR $P_{1}$	PRECEPT Steps	ExpeL Steps	FR Steps
1st	44.8% $\pm$ 10.7	36.6% $\pm$ 12.7	38.8% $\pm$ 8.3	3.24 $\pm$ 0.26	4.19 $\pm$ 0.48	4.12 $\pm$ 0.26
2nd	82.5% $\pm$ 12.1 ∗∗	65.0% $\pm$ 19.2	62.5% $\pm$ 15.2	2.38 $\pm$ 0.26	3.05 $\pm$ 0.57	3.40 $\pm$ 0.63
3rd	87.5% $\pm$ 9.4 ∗∗	72.5% $\pm$ 13.2	60.0% $\pm$ 12.5	2.25 $\pm$ 0.19	2.80 $\pm$ 0.42	3.50 $\pm$ 0.58
4th	100.0% $\pm$ 0.0 ∗∗	85.0% $\pm$ 12.5	67.5% $\pm$ 17.0	2.00 $\pm$ 0.00	2.50 $\pm$ 0.38	3.20 $\pm$ 0.64
$\Delta$ (1st $\rightarrow$ 4th)	+55.2pp	+48.4pp	+28.7pp	$-$ 1.24	$-$ 1.69	$-$ 0.92

Table 17: Experiment 4 continuous learning on logistics across sequential encounters.

Encounter	PRECEPT $P_{1}$	ExpeL $P_{1}$	FR $P_{1}$	PRECEPT Steps	ExpeL Steps	FR Steps
1st	30.3% $\pm$ 12.6 ∗	18.5% $\pm$ 9.0	16.8% $\pm$ 9.2	3.95 $\pm$ 1.19	4.38 $\pm$ 1.28	4.45 $\pm$ 1.31
2nd	51.4% $\pm$ 19.6 ∗∗	21.1% $\pm$ 8.5	17.7% $\pm$ 11.2	3.11 $\pm$ 1.05	4.43 $\pm$ 1.29	4.49 $\pm$ 1.34
3rd	63.5% $\pm$ 22.1 ∗∗∗	27.2% $\pm$ 14.2	23.5% $\pm$ 19.2	2.61 $\pm$ 0.92	4.17 $\pm$ 1.28	4.24 $\pm$ 1.39
4th	70.4% $\pm$ 23.8 ∗∗∗	30.6% $\pm$ 15.7	26.9% $\pm$ 17.5	2.33 $\pm$ 0.87	4.04 $\pm$ 1.25	4.22 $\pm$ 1.35
$\Delta$ (1st $\rightarrow$ 4th)	+40.1pp	+12.0pp	+10.1pp	$-$ 1.62	$-$ 0.35	$-$ 0.23

Table 18: Experiment 4 continuous learning on integration across sequential encounters.

Figure 12: Experiment 5 rule persistence after session restart. PRECEPT retains learned rules far more faithfully than the approximate-retrieval baselines.

Domain	Metric	PRECEPT	Full Reflexion	ExpeL
Integration	Enc. 1 $P_{1}$	100.0% $\pm$ 0.0	31.9% $\pm$ 9.5	33.3% $\pm$ 11.9
	Enc. 4 $P_{1}$	100.0% $\pm$ 0.0	44.8% $\pm$ 18.8	46.7% $\pm$ 17.4
	Overall $P_{t}$	100.0% $\pm$ 0.0	33.7% $\pm$ 10.6	35.6% $\pm$ 11.4
	Avg Steps	2.00 $\pm$ 0.00	4.69 $\pm$ 0.39	4.62 $\pm$ 0.46
Logistics	Enc. 1 $P_{1}$	88.5% $\pm$ 8.8	58.0% $\pm$ 16.3	68.5% $\pm$ 14.6
	Enc. 4 $P_{1}$	100.0% $\pm$ 0.0	70.0% $\pm$ 29.0	92.5% $\pm$ 7.5

Table 19: Experiment 5 rule persistence after session restart across integration and logistics.

Panel of Figure 13 — Figure 13: Experiment 6 static-knowledge ablation (Type I conflict). Adversarial in-vocabulary static knowledge harms first-try performance, but PRECEPT retains the largest margins and the strongest retry-time recovery.

Domain	Configuration	PRECEPT $P_{1}$	FR $P_{1}$	ExpeL $P_{1}$	PRECEPT $P_{t}$	FR $P_{t}$	ExpeL $P_{t}$
Integ.	With Adv. SK	80.0 $\pm$ 9.4	38.3 $\pm$ 8.0	46.7 $\pm$ 5.0	81.7 $\pm$ 8.8	43.3 $\pm$ 8.3	48.3 $\pm$ 3.8
	Without SK	85.0 $\pm$ 8.8	38.3 $\pm$ 9.8	50.0 $\pm$ 0.0	88.3 $\pm$ 9.8	48.3 $\pm$ 3.8	50.0 $\pm$ 0.0
	SK Effect	$-$ 5.0pp	0.0pp	$-$ 3.3pp	$-$ 6.7pp	$-$ 5.0pp	$-$ 1.7pp
Logist.	With Adv. SK	92.5 $\pm$ 7.5	60.0 $\pm$ 12.5	85.0 $\pm$ 12.5	100.0 $\pm$ 0.0	85.0 $\pm$ 12.5	95.0 $\pm$ 5.0
	Without SK	97.5 $\pm$ 2.5	57.5 $\pm$ 18.9	85.0 $\pm$ 15.0	97.5 $\pm$ 2.5	87.5 $\pm$ 12.5	97.5 $\pm$ 2.5
	SK Effect	$-$ 5.0pp	+2.5pp	0.0pp	+2.5pp	$-$ 2.5pp	$-$ 2.5pp

Table 20: Static knowledge ablation: impact of in-vocabulary adversarial static knowledge on all agents across both domains (

N{=}10

seeds). Adversarial SK recommends valid but incorrect options drawn from the same solution pool agents choose from.

Theoretical Prediction	Empirical Result	Verdict
Ensemble detector fires on genuine conflicts ( $\theta{=}0.30$ from §4.1)	73–472 conflicts detected per seed; zero without SK	Confirmed
Beta priors: static $=$ 0.50, dynamic $=$ 0.625 (Def. 4.1)	Exact match in all 20 without-SK runs	Confirmed
Posteriors shift toward dynamic source (Def. 4.1 update rule)	Static drops to 0.01–0.06; dynamic rises to 0.96–0.99	Confirmed
Conflicts resolved in favor of dynamic (Alg. 4.1)	0 static wins across all 20 with-SK runs	Confirmed
$P_{1}$ penalty from adversarial SK (Thm. B.1, reduced $\alpha$ )	$-$ 5.0pp on both domains	Confirmed
Bayesian recovery after conflict resolution (Thm. 4.1, stationary-segment TS behavior)	Complete on logistics ( $P_{t}{=}100\%$ ); partial on integration	Confirmed

Table 21: Theory–experiment alignment for Type I conflict resolution across 40 trace-analyzed runs. The empirical results confirm the predictions of Definition 4.1, Algorithms 4.1a–4.1b, Theorem B.1, and the stationary-segment interpretation of Theorem 4.1.

Figure 14: Experiment 7 rule drift adaptation. After the train–test mapping shift, PRECEPT shows the strongest recovery across encounters in both domains.

Domain	Enc.	PRECEPT $P_{1}$	FR $P_{1}$	ExpeL $P_{1}$	PRECEPT $P_{t}$	FR $P_{t}$	ExpeL $P_{t}$
Integr.	1st	37.5 $\pm$ 16.6	11.5 $\pm$ 11.1	7.0 $\pm$ 8.1	37.5 $\pm$ 16.6	24.0 $\pm$ 21.8	24.8 $\pm$ 20.8
	2nd	37.5 $\pm$ 16.6	19.8 $\pm$ 13.4	14.5 $\pm$ 12.3	48.7 $\pm$ 22.9	26.8 $\pm$ 12.6	33.0 $\pm$ 12.8
	3rd	48.7 $\pm$ 22.9	16.5 $\pm$ 13.6	13.5 $\pm$ 10.8	58.2 $\pm$ 23.8	26.0 $\pm$ 15.1	28.0 $\pm$ 15.3
	4th	60.7 $\pm$ 22.5	19.8 $\pm$ 15.8	29.7 $\pm$ 12.8	69.0 $\pm$ 25.2	32.7 $\pm$ 11.4	38.0 $\pm$ 13.2
	$\Delta$	+23.2pp	+8.3pp	+22.7pp	+31.5pp	+8.7pp	+13.2pp
Logist.	1st	28.3 $\pm$ 20.3	40.0 $\pm$ 23.6	35.7 $\pm$ 17.3	72.7 $\pm$ 18.4	68.3 $\pm$ 20.9	75.7 $\pm$ 19.5

Table 22: Experiment 7 rule drift adaptation across encounters after a train–test mapping shift.

Capability	PRECEPT	Full Refl.	ExpeL	Trad. RL
Compositional Gen. $O(2^{N})$	✓	$\times$	$\times$	$\times$
Continuous Learning	✓ (+40–55pp)	$\triangle$ (+10–29pp)	$\triangle$ (+12–48pp)	$\times$
Rule Persistence	✓ (88.5–100%)	$\triangle$ (32–70%)	$\triangle$ (33–93%)	$\times$
Rule Drift Adaptation	✓ (+55pp)	$\times$ (+3.8pp)	$\triangle$ (+41pp)	$\times$
Exact Multi-Cond. Match	✓	$\times$	$\times$	$\times$
Static-Dynamic Conflict	✓	$\times$	$\times$	$\times$

Table 23: Capability matrix summarizing which properties are fully, partially, or not supported across methods.

Capability	DRQ	PRECEPT
Knowledge retrieval	None (de novo generation)	$O(1)$ exact-match; 0% error at $N{=}10$ (Thm. B.6)
Compositional structure	Monolithic programs	$2^{N}{-}1$ coverage from $N$ atomic rules (Thm. 3.1)
Conflict resolution	Win/loss selection only	Bayesian ensemble + Thompson Sampling (Def. 4.1)
Drift handling	Population dynamics	Per-rule invalidation; $64\times$ model-based resilience bound (Cor. B.5)
Cyclic failure prevention	No guarantee	$P(\text{repeat})=0$ via deterministic pruning (Thm. 4.5)
Compute allocation	Uniform mutation	ML-based complexity; rollout reduction

Table 24: PRECEPT vs. DRQ: original contributions beyond evolutionary inspiration.

Appendix figures & tables5 assets

Supplementary material from the paper’s appendix.

Appendix

Parameter	Module	Value
Rule Invalidation
Failure threshold ( $\theta$ )	precept_mcp_server.py	2
Confidence decay ( $\delta$ )	precept_mcp_server.py	$\times$ 0.5
Confidence restore	precept_mcp_server.py	+0.25
Conflict Resolution
Ensemble conflict threshold	conflict_resolution.py	0.30

Appendix

Table 25: Hyperparameter settings used by the main PRECEPT subsystems.

Symbol	Definition
$\alpha$	Learning effectiveness: probability that a learned rule is correctly retrieved and applied
$N$	Number of conditions in a composite scenario (condition count)
$E$	Number of unique condition keys in a domain
$\beta$	Training exposure factor (number of training passes per condition)
$W$	Number of “white-box” (trivially solvable) scenarios in a test set
$B$	Number of “black-box” (learning-required) scenarios in a test set

Appendix

Table 26: Notation and parameter definitions used in the theoretical analysis.

Feature	Implementation	Description
Structured Outputs	_call_llm_structured()	Pydantic models ensure guaranteed schema from LLM
Procedural Memory	store_procedure()	Learns recovery procedures from successful error recovery
Epistemic Probing	execute_probe()	Diagnostic probes discover hidden constraints
Online Validation	register_task_for_online_validation()	Real-time task registration for verified evolution
Partial Progress	record_failed_option()	Persists failed options across episodes
COMPASS Error Eval	evaluate_error()	Classifies errors by constraint tier

Appendix

Table 28: Extended agent features used in the evaluated PRECEPT system.

Option	Default	Description
disable_exhausted_exit	False	Continue exploration when LLM signals “EXHAUSTED”
enable_random_fallback	False	Random selection when all options exhausted
soft_constraints_retriable	False	Allow retrying SOFT constraint failures
enable_compositional_generalization	False	Enable atomic constraint stacking
enable_atomic_precept_storage	False	Store tier-annotated atomic precepts
enable_hybrid_parsing	False	Use rule-based + LLM fallback for task parsing

Appendix

Table 29: Configurable agent options and their default settings.

Domain	Strategy	Special Features
Logistics	LogisticsDomainStrategy	Port routing, customs handling
Booking	BookingDomainStrategy	Flight/hotel reservations
Integration	IntegrationDomainStrategy	OAuth, API webhooks

Appendix

Table 30: Domain-specific strategy extensions for the evaluated domains.

LLM Agents

Large language model agents use language models to plan, use tools, and act across multi-step tasks and environments.

See all 705 papers

Oct 19, 2026

AdaExploreBench: Benchmarking LLM Agents for Proactive Exploration and Test-time Adaptation in Evolving Environments

Large Language Model (LLM) agents are increasingly deployed in unfamiliar and evolving environments, requiring them to proactively explore, understand, and adapt to environmental dynamics. However, existing benchmarks rarely test whether agents can proactively discover how an environment works and adapt as it evolves. To address this gap, we introduce AdaExploreBench, a benchmark for proactive exploration and test-time adaptation in evolving environments. By instantiating environmental dynamics as hidden rules, AdaExploreBench requires agents to actively acquire evidence and infer the rules. Under implicit rule drift, the latent rule changes without announcement, requiring agents to detect from degraded performance that prior knowledge is stale and re-explore. Experiments on eight leading LLMs show that proactive and adaptive exploration remain challenging: GPT-6 Sol achieves only 61.9% calibrated accuracy, while providing sufficient evidence or removing rule drift improves average performance significantly by close to 10%. These results reveal a critical bottleneck in current LLM agents: they can often reason effectively from informative evidence once it is available, but struggle to actively acquire the right evidence and recognize when previously acquired evidence is no longer valid.

Rui Wang, Zishen Lai, Jiayu Liu +15

HKUST · HKUST-UGAIL · HKUST(GZ) +3

LLM Agent Evaluation AI Agent Benchmarks LLM Agents Inference-Time Adaptation of Language Models

Ask PDF

Sep 28, 2026

Learn Now, Use Next, Trust Later: Prequential Test-Time Learning for LLM Agents

Adapting large language model agents during deployment requires not only retaining past experience, but also turning new observations into timely guidance. Many test-time learning methods, however, acquire knowledge from completed episodes. Feedback from an ongoing interaction may therefore not be distilled into knowledge soon enough to help the next decision. Acquiring knowledge at the granularity of individual transitions could reduce this delay, but raises a separate challenge: a rule that is useful within one episode may not be reliable enough to guide future episodes. Waiting for validation can forfeit immediate benefits, whereas unrestricted reuse can propagate accidental or misattributed guidance. We introduce StepLearn, a nonparametric framework that separates immediate use from persistent trust. It turns informative transitions into hypotheses that can guide the next step, while requiring prospective validation before reuse across episodes. Their predicted effects are checked against subsequent observations outside the source episodes, and only sufficiently supported hypotheses become available for persistent guidance. This process updates external knowledge while keeping all model parameters fixed. Over five rounds on WebArena-Lite and ALFWorld, StepLearn achieves average success rates of 59.9% and 84.0% with GPT-5-mini, and 57.8% and 88.1% with Qwen3.5-35B-A3B, respectively. It outperforms EvoTest, the strongest baseline, by 2.2-12.7 percentage points across the four settings. Learning dynamics further shows that these gains are not restricted to the final repetition, with advantages already present on first task attempts in most settings.

Tong Zhao, Reed Li, Yuyang Hu +5

Renmin University of China · Tencent

Continual Learning for LLM Agents Test-Time Training LLM Agent Reliability

Ask PDF

Jun 4, 2026

RECAP: Regression Evaluation for Continual Adaptation of Prompts

Production agentic systems routinely face evolving constraints and must comply from the very next interaction. Scenarios like a tool-call notification changing a compliance threshold or a policy update adding disclosure requirements fit this criteria, having close to no room for errors in production. This proactive adaptation setting is common in deployment, but absent from current benchmarks, which assume either static constraint sets or reactive protocols with evaluation feedback. We introduce RECAP, a benchmark that measures continual-learning phenomena (forgetting, regression, forward transfer) at the constraint level under a strictly proactive adapt-then-test protocol: prompt optimization methods receive only the constraint specification and must generalize before seeing any test data. Evaluating six methods across five LLMs and three schedules with evolving constraints, we find that these methods show no significant improvement in performance, even after incurring a higher latency. These methods, designed for offline or reactive settings, are inadequate for the proactive paradigm. Our work emphasizes the growing need for designing proactive prompt adaptation methods, where the models must remain robust to evolving needs in deployment.

Harsh Deshpande, Kushal Chawla, Sangwoo Cho +2

Capital One

Continual Learning for LLMs LLM Evaluation Instruction Following

Ask PDF

Abstract

LLM Agents

Explore similar work

AdaExploreBench: Benchmarking LLM Agents for Proactive Exploration and Test-time Adaptation in Evolving Environments

Learn Now, Use Next, Trust Later: Prequential Test-Time Learning for LLM Agents

RECAP: Regression Evaluation for Continual Adaptation of Prompts