Reflection-on-Demand Strategy

• Reflection-on-Demand Strategy is a computational design paradigm that balances efficiency and accuracy by invoking reflective inference selectively.
• It employs trigger mechanisms based on conditions such as failure, uncertainty, novelty, and risk to allocate reflective resources optimally.
• Practical applications span LLM reasoning, agentic planning, secure code generation, and runtime systems, demonstrating its broad utility.

Searching arXiv for papers on reflection-on-demand and selective reflection. Reflection-on-Demand Strategy denotes a family of computational designs in which reflective processing is invoked selectively rather than continuously. Across recent work, the common pattern is a separation between a default or intuitive inference mode and a more expensive reflective mode, with a control mechanism that decides when reflection is warranted by signals such as failure, uncertainty, novelty, risk, milestone progress, or expected benefit relative to cost. In contemporary machine learning, the term is associated with selective self-correction in LLMs, adaptive control of reflection tokens or latent reflection representations, event-triggered replanning in agents, and feedback-conditioned strategy revision in planning systems (Byrd, 29 May 2025). In broader computing, analogous ideas appear in runtime semantic reflection, metalevel strategy synthesis, and reflective middleware, where higher-level introspection or transformation is materialized only when demanded by the execution context (Rideau, 1 Jun 2026, Rubio et al., 2024, Portillo et al., 2010).

1. Conceptual definition and normative rationale

A reflection-on-demand strategy treats reflection as a resource allocation problem rather than an always-on property. The central normative claim in "Strategic Reflectivism In Intelligent Systems" is that intelligent systems should perform "pragmatic switching between intuitive and reflective inference to optimally fulfill competing goals" (Byrd, 29 May 2025). In this view, reflection is neither intrinsically superior nor dispensable; it is recruited when it improves the tradeoff among accuracy, cost, latency, and other objectives.

The same selective logic recurs in later technical formulations. "CyclicReflex: Improving Large Reasoning Models via Cyclical Reflection Token Scheduling" treats reflection tokens as a resource whose excessive or insufficient use can each degrade performance, motivating dynamic allocation during decoding (Fan et al., 4 Jun 2025). "ReflCtrl: Controlling LLM Reflection via Representation Engineering" similarly frames self-reflection as useful but costly, and studies how to steer it continuously or suppress it when redundant, reporting that many reflection steps are redundant, especially in stronger models (Yan et al., 16 Dec 2025). "Reflecting with Two Voices: A Co-Adaptive Dual-Strategy Framework for LLM-Based Agent Decision Making" operationalizes the same principle through score-triggered replanning, where global reflection occurs only under stagnation or milestone progress (Zhang et al., 9 Dec 2025).

This convergence suggests a broad characterization: reflection-on-demand is a control policy over reflective computation. A plausible implication is that the relevant research question is not whether a system can reflect, but how reflective effort should be budgeted over time, instances, and stages of computation.

2. Trigger mechanisms and control policies

Most recent formulations define explicit trigger conditions for entering or halting reflection. In the conceptual account of Strategic Reflectivism, reflection is invoked when the task is novel, high-stakes, imaginative, in conflict with other information, or associated with low confidence, and it is halted when marginal gains no longer justify time or compute cost (Byrd, 29 May 2025). This establishes the general architecture: a meta-process decides whether to intervene on a default response.

In agentic settings, triggers are often formalized numerically. DuSAR uses a Strategy Fitness Score $s_t \in [0,100]$ computed after each action from the current observation, action, reward, and trace history (Zhang et al., 9 Dec 2025). Its update rule is:

$$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$

Here, reflection is triggered by either failure ($s_{t-1}=0$) or meaningful advancement ($50 \leq s_{t-1} \leq 99$), while plan maintenance persists during ordinary progress ($1 \leq s_{t-1} \leq 49$) (Zhang et al., 9 Dec 2025). This is a strict event-triggered formulation.

In secure code generation, "Reflection-Driven Control for Trustworthy Code Agents" uses a binary front-end router: a concise self-check produces SAFE or UNSAFE, with deep reflection-and-repair triggered only in the UNSAFE case (Wang et al., 22 Dec 2025). The verdict is modeled as a binary safety classifier, and SAFE cases are stored directly while UNSAFE cases activate retrieval, repair, and verification (Wang et al., 22 Dec 2025). In generalized planning, reflection is failure-triggered: a pseudocode strategy is revised only after VAL reports a failed plan, and Python code reflection is invoked only after a debugging failure is observed (Stein et al., 19 Aug 2025).

Some work replaces explicit symbolic triggers with representational or lexical control. ReflCtrl extracts a latent reflection direction and applies stepwise steering only when a new thinking step begins, using the delimiter \n\n as the boundary condition (Yan et al., 16 Dec 2025). CyclicReflex modulates the logit of reflection tokens according to decoding position, alternating promotion and suppression rather than making a one-time trigger decision (Fan et al., 4 Jun 2025). In these models, reflection-on-demand is implemented as time-varying regulation rather than discrete routing.

3. Reflection in LLM reasoning

In reasoning LLMs, reflection-on-demand has been studied at three distinct levels: emergence, token-level scheduling, and latent-space control.

"Rethinking Reflection in Pre-Training" argues that reflection begins to emerge during pre-training rather than only during reinforcement learning (AI et al., 5 Apr 2025). The paper evaluates six adversarial datasets—BBH, cruxeval-i, cruxeval-o, GSM8K, GSM8K-Platinum, and TriviaQA—by introducing deliberate errors into chains-of-thought and appending a continuation cue such as "Wait," (AI et al., 5 Apr 2025). It distinguishes situational-reflection from self-reflection, and explicit reflection from implicit reflection. The reported result that an OLMo-2-7B model trained on 198B tokens already demonstrates reflection across math, code, verbal, and logical reasoning supports the claim that reflection-on-demand can be elicited by lightweight cues rather than requiring an external reflective architecture (AI et al., 5 Apr 2025). The paper also reports that 231 of 240 dataset-checkpoint pairs show at least one instance of situational reflection, and 154 of 240 show at least one instance of self-reflection (AI et al., 5 Apr 2025).

CyclicReflex operates directly on reflection tokens such as "wait", "but", and "alternatively" (Fan et al., 4 Jun 2025). It generalizes the TIP baseline, which adds a constant bias to reflection-token logits in an early decoding window,

$$\mathrm{TIP}(\alpha): \quad \hat{z}_{t,v} = \begin{cases} z_{t,v} + \alpha, & \text{if } v \in \hat{V} \text{ and } t < T_0 \ z_{t,v}, & \text{otherwise} \end{cases}$$

by introducing a position-dependent triangular waveform,

$$\hat{z}_{t,v} = \begin{cases} z_{t,v} + \delta(t), & \text{if } v \in \hat{V} \ z_{t,v}, & \text{otherwise} \end{cases}$$

with

$$\delta(t) = A \left| 4 \cdot \frac{(t - \frac{C}{4}) \bmod C}{C} - 2 \right| - A.$$

This cyclical schedule alternates between promotion and suppression of reflection tokens, motivated by the claim that both under-reflection and over-reflection degrade performance (Fan et al., 4 Jun 2025). On MATH500, AIME2024, AIME2025, and AMC2023, the method improves performance across DeepSeek-R1-Distilled Qwen 1.5B, Qwen 7B, and Llama 8B models, outperforming standard decoding, TIP, S1, and silver scheduling in most settings (Fan et al., 4 Jun 2025).

ReflCtrl studies reflection as a latent-space property. It segments reasoning traces into steps using \n\n, labels reflection steps by keywords such as "Let me think" and "Wait", and computes a reflection direction as the difference between mean hidden representations of reflection and non-reflection steps (Yan et al., 16 Dec 2025):

$$d_l^{\{\text{attn,mlp}\}} = \frac{1}{|\text{R}|}\sum_{s \in \text{R}} z_l^{\{\text{attn,mlp}\}(s)} - \frac{1}{|\text{NR}|}\sum_{s \in \text{NR}} z_l^{\{\text{attn,mlp}\}(s)}.$$

Inference is then steered by adding $\lambda d_l$ only at step boundaries, not at every token. The paper reports that reflection consumes 25–30% of total reasoning tokens and that up to 33.6 percent of reasoning tokens can be saved while preserving performance (Yan et al., 16 Dec 2025). It also shows that the reflection direction is highly correlated with an internal uncertainty signal, with logistic-regression probes based on cosine similarity to the reflection direction outperforming baselines based on the final-layer embedding on correctness prediction (Yan et al., 16 Dec 2025). This suggests that reflection-on-demand can be grounded in model-internal uncertainty estimation.

4. Agentic and planning architectures

In agent systems, reflection-on-demand is often embedded into multistage control loops that separate planning, execution, diagnosis, and repair.

MIRROR introduces both intra-reflection and inter-reflection in multi-agent tool use (2505.20670). Intra-reflection is a local pre-action self-evaluation performed by the Planner Agent, Tool Agent, and Answer Agent against role-specific thresholds $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$0, $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$1, and $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$2; outputs below threshold are revised before execution (2505.20670). Inter-reflection is trajectory-level adaptation using Short-Term Memory and Long-Term Memory, where recent failures influence local repair and failed full trajectories are stored for replanning (2505.20670). The paper evaluates on StableToolBench and TravelPlanner, reporting, for example, 83.7% average Pass Rate with GPT-3.5 Turbo on StableToolBench, and clear gains over ReAct, Reflexion, Smurfs, and SFT-based baselines (2505.20670). The ablations show lower performance without planner intra-reflection, tool intra-reflection, answer intra-reflection, inter-reflection, or reflection entirely, indicating that selective reflection at multiple stages materially contributes to performance (2505.20670).

DuSAR employs a different architecture: a Holistic Strategy $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$3, a Local Strategy $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$4, and Decision Reflecting for action selection (Zhang et al., 9 Dec 2025). Reflection is not attached to every step symmetrically. Local reflection is continuous in the sense that it grounds each action in the current observation and trace, but global reflection is event-triggered by the Strategy Fitness Score. This produces a token-efficient coordination between global planning and local execution. The paper reports 37.1% success on ALFWorld with Llama3.1-70B and 4.02% on Mind2Web, while reducing per-step token consumption by 3–9X relative to retrieval-heavy baselines (Zhang et al., 9 Dec 2025).

In generalized planning with LLMs, the reflection-on-demand strategy appears as failure-driven strategy debugging (Stein et al., 19 Aug 2025). The system first generates pseudocode rather than a loose natural-language strategy, then uses that pseudocode to generate plans for debugging tasks, validates them with VAL, and inserts a reflection stage before pseudocode revision. Python debugging is similarly augmented: the model receives positive and negative feedback and is explicitly prompted to "pinpoint the location and reason of the error" before revising the code (Stein et al., 19 Aug 2025). Across 17 benchmark domains, average coverage rises from 37 for both the original Silver framework and the baseline reimplementation to 60 for configuration F3 and 58 for F5; best-run coverage rises to 74 for F3 and 76 for F5 (Stein et al., 19 Aug 2025). The ablations report that removing strategy debugging, multiple initial code programs, or code reflection yields clearly worse performance overall, with Miconic and Transport showing coverage drops of at least 88 points when any of the three is removed (Stein et al., 19 Aug 2025).

In secure code generation, Reflection-Driven Control instantiates an in-loop Plan–Reflect–Verify pipeline (Wang et al., 22 Dec 2025). A reflective memory repository combines dynamic memory $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$5 implemented with ChromaDB and static memory $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$6 built from secure coding standards and vulnerability databases. Retrieval is conditioned on similarity and minimum recall thresholds, and retrieved repairs plus secure coding guidelines are injected as evidence-based constraints into the reflective prompt (Wang et al., 22 Dec 2025). The paper reports Security Rate improvements from 93.7 to 96.6 for gpt-3.5-turbo, 85.7 to 95.0 for gpt-4o, 83.7 to 94.9 for qwen3-coder-plus, and 88.0 to 97.1 for gemini-2.5-pro, while Pass Rate is largely preserved except for a drop from 86.7 to 80.1 for qwen3-coder-plus (Wang et al., 22 Dec 2025). It further finds that a single well-structured reflection round captures most of the value, with later rounds showing diminishing returns (Wang et al., 22 Dec 2025).

5. Memory, retrieval, and evidence-grounded reflection

A recurring design principle is that reflection-on-demand is often coupled to memory rather than purely recomputation. Meta-Reflection, although only described at the abstract level in the available material, proposes a feedback-free mechanism in which reflective insights from past experiences are integrated into a codebook for storage, retrieval, and reuse in guiding later problem solving (Wang et al., 2024). This design shifts the emphasis from iterative external critique toward retrieval of historically accumulated reflections.

Reflection-Driven Control provides a more explicit memory architecture. Dynamic memory $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$7 stores verified repair cases; static memory $$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$8 stores secure coding standards, vulnerability databases, and fixed safety artifacts (Wang et al., 22 Dec 2025). When an unsafe case is detected, the system retrieves top-$$H_t = \begin{cases} H_{\text{Ref}(I, E_{<t}, H_{t-1})} & \text{if } s_{t-1} = 0 \text{ or } 50 \leq s_{t-1} \leq 99 \ H_{t-1} & \text{if } 1 \leq s_{t-1} \leq 49 \ \text{Terminate} & \text{if } s_{t-1} = 100 \end{cases}$$9 evidence from $s_{t-1}=0$0 if similarity is high enough, otherwise from $s_{t-1}=0$1, and then injects retrieved examples and guidelines into subsequent reasoning (Wang et al., 22 Dec 2025). The paper states that the first reflection round captures about 90% of critical repair patterns using the top-3 high-similarity retrieved cases (Wang et al., 22 Dec 2025). This is a concrete instantiation of evidence-grounded reflection rather than free-form self-deliberation.

MIRROR uses a two-timescale memory design: Short-Term Memory retains recent execution failures and intra-reflection outputs within a task, while Long-Term Memory stores the whole trajectory when task-level repair is needed (2505.20670). DuSAR maintains an explore trace $s_{t-1}=0$2, with a sliding window of $s_{t-1}=0$3, so reflective updates depend on structured recent experience rather than only the current observation (Zhang et al., 9 Dec 2025). These systems differ in application domain, but both instantiate selective reflection as memory-mediated control.

This suggests a useful distinction between two variants of reflection-on-demand. One variant is diagnostic: reflection is computed anew from current signals. The other is retrieval-mediated: the system reflects by recalling prior reflective artifacts, repair cases, or trajectories. The latter is prominent in Meta-Reflection and Reflection-Driven Control (Wang et al., 2024, Wang et al., 22 Dec 2025).

6. Reflection outside LLM inference: runtime systems, metaprogramming, and infrastructure

The same selective reflective logic appears in several non-LLM domains, where reflection is activated only when execution requires a higher level of abstraction or reconfiguration.

"Climbing Up the Semantic Tower -- at Runtime" formulates runtime reflection as a protocol extracted from a semantic specification of implementations (Rideau, 1 Jun 2026). Software is modeled as a semantic tower, where a concrete computation implements a more abstract one. The central notion is a generalized safe point: from any interrupted concrete fragment $s_{t-1}=0$4, there exists a safe continuation $s_{t-1}=0$5 to an observable state corresponding to some abstract continuation $s_{t-1}=0$6,

$s_{t-1}=0$7

This supports upward movement in the semantic tower only when needed: the system normally executes at the concrete level, but when reflection is requested it computes a safe continuation to an abstractly observable point, performs intervention there, and then pushes changes back down (Rideau, 1 Jun 2026). This is reflection-on-demand in a literal runtime semantics sense.

In reflective Maude, "Metalevel transformation of strategies" treats strategies as metalevel terms of sort Strategy, allowing them to be generated or transformed only when a task requires module-specific control (Rubio et al., 2024). The paper presents csrTransform, which converts a module into a strategy module with generated strategies such as norm-via-munorm, munorm, and decomp, derived from context-sensitive annotations and the operator signature (Rubio et al., 2024). The principle is explicitly selective: metalevel programming is used to synthesize or extend strategies only when necessary, after which the resulting strategies are executed by the built-in strategy engine (Rubio et al., 2024).

"A Reflective Approach to Providing Flexibility in Application Distribution" applies related ideas to middleware (Portillo et al., 2010). RAFDA transforms bytecode so that distribution boundaries are not fixed at design time. For each class A, it generates interfaces such as A_O_Int and A_C_Int, local implementations such as A_O_Local, protocol-specific proxies such as A_O_Proxy_SOAP and A_C_Proxy_RMI, and factories such as A_O_Factory and A_C_Factory (Portillo et al., 2010). Distribution is thereby introduced or altered only when runtime policy demands it. The paper characterizes this as dynamically altering distribution boundaries, making distribution a runtime-configurable property rather than a compile-time decision (Portillo et al., 2010).

"Metaclasses and Reflection in Smalltalk" addresses reflective control of inheritance strategies (Clark, 2018). Its ASMIRS model makes send itself reflective by delegating message dispatch to the class of the object, so different classes can implement different inheritance traversals or object representations (Clark, 2018). Reflection is thus invoked at the level of message delivery only where class-specific control is needed. A plausible implication is that reflection-on-demand in programming-language design often means exposing previously intransigent mechanisms—dispatch, inheritance, runtime representation—as overridable metalevel services.

7. Debates, limitations, and recurrent technical tensions

The recent literature converges on several cautions. First, more reflection is not uniformly better. Strategic Reflectivism explicitly rejects model size and chain-of-thought as reliable proxies for genuine reflective inference, warning that reflective reasoning can slow down or even worsen decisions (Byrd, 29 May 2025). CyclicReflex shows empirically that both over-reflection and under-reflection hurt performance (Fan et al., 4 Jun 2025). ReflCtrl reports that many reflections are redundant, especially in stronger models, and that reflection control should trade off token budget and accuracy rather than maximizing introspection (Yan et al., 16 Dec 2025).

Second, the control signal itself is often imperfect. In generalized planning, failure-triggered reflection receives correct external feedback from VAL with respect to the failed plan, but the model’s reflective explanation may not perfectly isolate the true underlying strategy bug (Stein et al., 19 Aug 2025). In DuSAR, the Strategy Fitness Score is generated by an LLM-based prompt rather than an external reward model, so its reliability is tied to the quality of progress analysis (Zhang et al., 9 Dec 2025). In Reflection-Driven Control, the SAFE/UNSAFE router is intentionally lightweight, which keeps costs low but places substantial responsibility on the self-check’s screening fidelity (Wang et al., 22 Dec 2025).

Third, theoretical understanding remains incomplete. CyclicReflex states that the theoretical foundations of under- and over-reflection remain underexplored, and that it is still unclear why LRMs exhibit these pathologies (Fan et al., 4 Jun 2025). ReflCtrl identifies strong correlation between the reflection direction and uncertainty, but presents uncertainty-aware dynamic steering as a future direction rather than a solved mechanism (Yan et al., 16 Dec 2025). Meta-Reflection proposes a feedback-free codebook mechanism and claims practical effectiveness, but the supplied material does not include technical details beyond the abstract, limiting any stronger characterization (Wang et al., 2024).

Fourth, selective reflection raises architectural choices about timing and granularity. Some systems reflect before action and after action, as in MIRROR (2505.20670). Some reflect only after observed failure, as in planning (Stein et al., 19 Aug 2025). Some modulate reflection continuously across decoding positions, as in CyclicReflex (Fan et al., 4 Jun 2025). Some intervene only at step boundaries in hidden space, as in ReflCtrl (Yan et al., 16 Dec 2025). These differences indicate that reflection-on-demand is not a single algorithm but a design space spanning trigger source, control granularity, memory dependence, and stage of intervention.

The overarching significance of the field is that reflection is increasingly treated as a schedulable computational primitive. Across reasoning models, agents, runtime systems, and reflective languages, the common goal is to preserve the benefits of reflective revision while avoiding unconditional deliberation, uncontrolled overhead, and brittle dependence on external critics. That selective orientation defines the contemporary research meaning of reflection-on-demand (Byrd, 29 May 2025).