acceptodds
Under review as a conference paper at ICLR 2027

FROM EXPERIENCE TO EXECUTION: STATE-CONDITIONED CONTROL FOR SMALL LANGUAGE MODEL AGENTS

Abstract

As language model agents move from answering questions to executing tasks, the substantial cost and data-exposure risks of remote inference make local small models an attractive deployment choice. Limited parameter capacity and reasoning ability, however, leave these models prone to accumulating errors in prerequisites, state tracking, and argument binding even in recurring workflows. Experience memory can provide the right procedure, but turning it into a current action still requires the model to resolve these local decisions. This difficulty motivates a control-theoretic approach that allocates decision freedom between the small model and its harness according to task state, assigning choices resolved by available evidence to external mechanisms. We propose state-conditioned control (SCC), which embeds trajectory experience as processes and dependencies, using soft guidance for unresolved choices and hard constraints and local execution for resolved steps. With frozen weights, SCC exceeds the strongest of four offline memory adaptations on the evaluated ToolSandbox, ALFWorld, and WebShop suites (13.12 score points, 61.94 and 3.80 success-rate points) and reuses its experience and rules with two additional small models. Channel and cost analyses reveal task-dependent gains and guidance costs, supporting decision allocation as a design variable for small-model agent harnesses. Our agent implementation is available at https://anonymous.4open.science/r/SCC-C6C3/.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Small Language Model Agents, State-Conditioned Control, Experience Transfer

Reviews

Among:
Shape:
1234this paper, Bottom 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.25 over 4 reviews, above 49% of the others.
Reviewer_AqVbOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes state-conditioned control (SCC) for frozen small language model agents. Expert trajectories are compiled into procedural structures that support current-state guidance, action restrictions, and direct execution of supported steps. With environment-specific adapters, SCC improves over four fixed offline memory adaptations on ToolSandbox, ALFWorld, and WebShop. Experiments include soft/hard channel ablations, online resource accounting, and reuse with two additional small models.

Critical strengths
  1. Useful improvements with frozen small models. SCC exceeds the strongest evaluated memory adaptation by 13.12 ToolSandbox score points, 61.94 ALFWorld success-rate points, and 3.80 WebShop success-rate points (Table 1). These results demonstrate practical value for the implemented harnesses without weight updates or online expert calls.

  2. Informative channel ablations. The four configurations share an environment core, initial states, and native-action budgets. Hybrid improves over Soft by 10.04 points on ToolSandbox and 24.63 percentage points on ALFWorld, while the corresponding WebShop interval includes zero (Table 11). This provides useful evidence about where the combined hard channel adds value.

Critical weaknesses
  1. The contribution of experience-derived decision allocation remains insufficiently isolated. SCC combines manually specified grammars, binding templates, and environment-specific controls (Table 7; Appendix C.4). These include ToolSandbox stopping guards, ALFWorld stage/object restrictions, and WebShop’s predefined option-before-purchase rule. The channel ablations switch these bundles together; they do not compare against generic guards alone or an experience-free scripted controller with comparable state information. Consequently, substantial gains could come from developers selecting control mechanisms suited to each environment, rather than specifically from the proposed use of expert experience to allocate decisions by state.

  2. The evaluation does not establish generalization beyond development-exposed tasks. Appendix A.1 states that the evaluated suites informed benchmark/model selection and refinements to guidance and constraints. Excluding 95 ToolSandbox source-overlap IDs preserves a 12.78-point gain, but related templates and development exposure remain (Appendix A.2). Reusing the controller with different models on these same suites does not resolve this issue. Although the paper acknowledges this limitation, independent evaluation is particularly important for a method with substantial manual controller design; otherwise, the reported improvements may depend on adaptation to the evaluated suites.

Questions for authors
  1. Attribution evidence: With generic stopping/repetition guards held fixed, how does SCC compare with an experience-free state controller using the same public information? This comparison is needed to distinguish the contribution of trajectory-derived dependencies from manual control design.

  2. Generalization evidence: Can you provide results on tasks or procedure families held out throughout controller development, with rules frozen before evaluation? Such evidence would directly address the development exposure described in Appendix A.1.

  3. Baseline clarification: Why omit AMD’s student-side subtask decomposition (Table 5), which can operate over a frozen memory store? Does restoring it, while charging its auxiliary inference cost, materially change the comparison?

  4. Cost clarification: Appendix F.2 excludes experience collection and store construction. What are these one-time costs, and how many subsequent tasks are needed to amortize them relative to direct expert execution?

3 comments
AuthorsOpenReview ↗

Response to Reviewer AqVb - Part 1

Thank you for acknowledging the practical effectiveness of SCC, as well as the analytical value of channel ablation across various control configurations. In response to your suggestions, we provide further details below regarding our experimental results and the corresponding statistical metrics, covering: (1) the contributions of empirical and manual control mechanisms; (2) task partitioning and the scope of generalization; (3) comparisons following the decomposition of the student-side AMD; and (4) one-time construction costs versus their amortization.

W1: The contribution of experience-derived decision allocation remains insufficiently isolated. SCC combines manually specified grammars, binding templates, and environment-specific controls (Table 7; Appendix C.4). These include ToolSandbox stopping guards, ALFWorld stage/object restrictions, and WebShop’s predefined option-before-purchase rule. The channel ablations switch these bundles together; they do not compare against generic guards alone or an experience-free scripted controller with comparable state information. Consequently, substantial gains could come from developers selecting control mechanisms suited to each environment, rather than specifically from the proposed use of expert experience to allocate decisions by state.

Q1: Attribution evidence: With generic stopping/repetition guards held fixed, how does SCC compare with an experience-free state controller using the same public information? This comparison is needed to distinguish the contribution of trajectory-derived dependencies from manual control design.

Response: With the public interfaces, state tracking, and generic guards retained, full SCC improves over the configuration without the graph-based procedure and its dependent mechanisms by 13.15 points on TS and 69.40 percentage points on ALF.

Stage guidance reads graph nodes, dependencies, and bindings, so it is removed together with the graph-based procedure and its dependent execution. TS retains tool-return fields and candidate arguments, while ALF retains native observations and internal tracking:

ConfigurationTS mean scoreALF success rate (%)
Graph-based procedure and dependent mechanisms removed43.3912.69
Full SCC56.5482.09

The two comparisons use the same 420 tasks and 134 games, respectively. The 95% CIs for the gains are [8.00, 18.63] and [61.19, 77.61]. They examine the combined contribution of the graph-based procedure and its guidance, constraints, and execution mechanisms.

Adding soft and hard control: Hybrid − NoneGain95% CI
TS mean score16.65[11.58, 22.01]
ALF success rate (percentage points)71.64[64.18, 79.10]
WS success rate (percentage points)9.80[6.90, 12.70]

W2: The evaluation does not establish generalization beyond development-exposed tasks. Appendix A.1 states that the evaluated suites informed benchmark/model selection and refinements to guidance and constraints. Excluding 95 ToolSandbox source-overlap IDs preserves a 12.78-point gain, but related templates and development exposure remain (Appendix A.2). Reusing the controller with different models on these same suites does not resolve this issue. Although the paper acknowledges this limitation, independent evaluation is particularly important for a method with substantial manual controller design; otherwise, the reported improvements may depend on adaptation to the evaluated suites.

Q2: Generalization evidence: Can you provide results on tasks or procedure families held out throughout controller development, with rules frozen before evaluation? Such evidence would directly address the development exposure described in Appendix A.1.

Response: We have tracked the development batches used for data collection alongside the IDs of the current evaluation tasks; any overlap is strictly limited to interface debugging. SCC reuses procedural experience and rules within the same environment, with objects and parameters dynamically rebound based on current observations. Consequently, the primary experimental results represent a large-scale generalization from the development set to the test set. The rules for selecting task IDs for experience collection are as follows: for TS and ALF, tasks are stratified by task family, and two batches of development tasks are selected using a fixed hash-based ordering; for WS, a fixed range of development goals is used. The current evaluation sets for TS exclude the specific task IDs used for experience collection, while for ALF and WS, the training sources and official evaluation sets are utilized. The results for tasks not included in the experience collection process are as follows:

EnvironmentNumber of Evaluation TasksSCC Results
TS42056.54 points
ALFWorld13482.09%
WebShop50032.60%
AuthorsOpenReview ↗

Response to Reviewer AqVb - Part 2

Q3: Baseline clarification: Why omit AMD’s student-side subtask decomposition (Table 5), which can operate over a frozen memory store? Does restoring it, while charging its auxiliary inference cost, materially change the comparison?

Response: We added AMD's student-side decomposition experiment. SCC still achieves higher scores and lower token costs on TS and ALF, leaving the paper's experimental conclusions unchanged.

MethodTS mean scoreTS tokens/task (k)ALF success rate (%)ALF tokens/task (k)
AMD (original baseline)43.7519.9414.1828.32
AMD + decomposition42.5914.9818.6626.58
SCC56.544.5982.0914.53

Q4: Cost clarification: Appendix F.2 excludes experience collection and store construction. What are these one-time costs, and how many subsequent tasks are needed to amortize them relative to direct expert execution?

Response: The estimated one-time teacher API cost for TS is CNY 139.34, which can be amortized after approximately 177 tasks relative to direct teacher execution. The teacher is DeepSeek-v4-pro, and the estimate uses recorded usage and a common reference rate.

ItemTS
Experience-collection API costCNY 139.34
Mean API cost of direct teacher executionCNY 0.7879/task
Tasks to amortize API cost177

The experience store is compiled by a deterministic program with no additional generative-model calls. TS adapter development took an estimated 64.7 minutes; this development effort is excluded from the teacher API cost above. SCC makes no teacher calls at runtime.

Thank you for the authors’ response. However, I still do not believe that the paper meets the standard for acceptance at this conference, and I will therefore retain my current score.

Reviewer_Xw19OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper introduces a state-conditioned control (SCC) framework for improving small language model agents by enabling state tracking more closely. The paper claims that smaller language models might be able to learn and use this memory effectively but fail to maintain a state, more closely, which could be solved by the SCC framework. This framework enables decision making by tracking state more closely and it chooses if it would be used for soft control or hard control, the idea is simple if the state exactly matches we might want to use hard control and use soft control otherwise. The paper evaluated SCC on ToolSandbox, ALFWorld, and WebShop, reporting improvements over four offline memory adaptations, as well as ablations of the control channels and analyses of inference costs.

Critical strengths
  1. The paper addresses an important problem in small language model agents: even when models have access to relevant procedural experience, they might fail to execute tasks reliably because they struggle to track the current state, satisfy prerequisites, and determine when to perform the next action. The SCC framework provides a practical way to address this limitation by making state tracking and execution decisions more explicit.
  2. The distinction between soft and hard control is intuitive. Soft control provides the model with state-conditioned guidance while leaving action selection to the model, whereas hard control restricts or directly executes actions when the current state and required arguments are sufficiently determined. This offers a simple mechanism for deciding which parts of execution require model reasoning and which can be handled by the controller.
  3. The paper evaluates SCC across three different environmens (ToolSandbox, ALFWorld, and WebShop) and compares it against four offline memory adaptations. The reported improvements, together with ablations of the control channels and analyses of inference costs, provide useful evidence about the potential benefits and trade-offs of incorporating state-conditioned control into agent systems.
Critical weaknesses
  1. The central idea behind SCC is intuitive, but the paper does not clearly establish what makes it a distinct methodological contribution beyond combining state tracking, structured procedural memory, action constraints, and deterministic execution. In particular, the decision to use hard control when the state and action are sufficiently determined appears to rely on manually specified conditions. It is unclear whether SCC provides a general principle for allocating decisions between the model and the controller, or whether this allocation is primarily an outcome of task-specific engineering.
  2. The evaluation does not fully isolate the contribution of experience-derived control from the manually engineered components of the framework. SCC relies on environment-specific action grammars, state fields, argument-binding templates, and execution checks. Consequently, the reported improvements could partly result from these additional mechanisms rather than from the proposed use of procedural experience. Comparisons against stronger state-machine or scripted-controller baselines would help establish how much of the improvement comes specifically from SCC.
  3. The generalizability of the approach remains unclear. Although the paper evaluates SCC across three environments and reuses it with different language models, the controller itself relies on manually defined environment-specific structures, and the evaluated suites informed its development. Cross-model compatibility does not necessarily demonstrate that the framework can generalize to unseen tasks, new procedures, or environments without substantial additional engineering. This limits the strength of the claim that SCC provides a broadly applicable solution to unreliable state tracking in small language models.
  4. The results suggest that the benefits of hard control depend on the environment, but the paper does not sufficiently explain when restricting the model's action space is beneficial. If the state representation is incomplete or an action has effects that are not captured by the controller, hard control could prevent the model from exploring valid alternatives. A clearer characterization of the conditions under which hard control helps, hurts, or should defer to soft control would strengthen the framework's motivation.
Questions for authors
  1. What is the underlying principle for deciding when control should be transferred from the language model to the SCC controller? The paper motivates hard control through sufficiently determined states and actions, but how is this condition formally defined? Could the same principle be applied to a new environment without manually specifying additional rules, or is the control policy inherently dependent on environment-specific engineering?
  2. How much of SCC's improvement comes from procedural experience, as opposed to the additional execution machinery? Could the authors compare SCC against a controller with the same state representation, action constraints, argument validation, and repetition guards, but without dependencies or procedures derived from experience? Such an experiment would help determine whether the experience-derived representation provides value beyond a conventional state-aware execution harness.
  3. What happens when the controller's state representation is incomplete or incorrect? Since hard control can restrict the model's available actions or execute actions directly, an incorrect state estimate could propagate into subsequent decisions. How does SCC detect and recover from these errors, and can the authors quantify performance as state observations become noisy, ambiguous, or unavailable?
4 comments
AuthorsOpenReview ↗

Response to Reviewer Xw19 - Part 1

Thank you for recognizing the design philosophy behind the soft and hard control of state conditions, as well as the value this mechanism brings to the execution reliability of small-scale models. In the following sections, we will address your questions regarding the methodology and its scope of application by discussing: (1) principles of control allocation and their formal definitions, (2) the contribution of experiential knowledge from past processes, (3) conditions for the application of hard control, (4) state verification and execution recovery, and (5) task transfer and environmental adaptation.

W1: The central idea behind SCC is intuitive, but the paper does not clearly establish what makes it a distinct methodological contribution beyond combining state tracking, structured procedural memory, action constraints, and deterministic execution. In particular, the decision to use hard control when the state and action are sufficiently determined appears to rely on manually specified conditions. It is unclear whether SCC provides a general principle for allocating decisions between the model and the controller, or whether this allocation is primarily an outcome of task-specific engineering.

Q1: What is the underlying principle for deciding when control should be transferred from the language model to the SCC controller? The paper motivates hard control through sufficiently determined states and actions, but how is this condition formally defined? Could the same principle be applied to a new environment without manually specifying additional rules, or is the control policy inherently dependent on environment-specific engineering?

Response: SCC takes over execution when current observations and procedural experience determine the action and its arguments, and the execution preconditions are satisfied. Otherwise, the language model continues to make decisions. We define eligibility for execution takeover as a Boolean predicate: c(x)=1 ⁣[M(x)∧B(x)∧P(x)∧E(x)∧R(x)]c(x)=\mathbf{1}\!\left[M(x)\land B(x)\land P(x)\land E(x)\land R(x)\right] Here, MM means that the procedure matches the current task and stage, BB that object and argument bindings are unambiguous and valid, PP that the action is legal and its preconditions hold, EE that automatic execution is enabled, and RR that sufficient budget remains. SCC executes the action directly only when all conditions hold; otherwise, the model continues to select actions. SCC's methodology allocates decision responsibilities between the model and its harness according to the current state (Sections 2 and 3). The same principle can be reused, while transfer to a new environment requires adapting state fields, action interfaces, argument bindings, and execution checks. The control rules and execution templates are manually defined. After adaptation, SCC uses trajectories from the environment to construct procedures and dependencies and determine which rules are enabled, then allocates control according to the current state and the same principle.

SCC draws its methodological insight from Ashby's law of requisite variety in control theory, which concerns the response capacity of the overall regulatory system to environmental variation. We view the model and harness as a joint regulatory system. Experience and public evidence allow the harness to handle local decisions. Decision freedom refers to task-relevant choices that remain with the model, while this allocation can reduce the understanding and exploration burden on the small model. Environmental feedback updates progress and bindings, which in turn changes subsequent guidance and intervention. This implements the control-theoretic perspective as a feedback loop connecting experience, state, and execution authority. Environments and tasks have different input/output formats and interface definitions, so transfer requires adapting these interfaces and rules.

AuthorsOpenReview ↗

Response to Reviewer Xw19 - Part 2

W2: The evaluation does not fully isolate the contribution of experience-derived control from the manually engineered components of the framework. SCC relies on environment-specific action grammars, state fields, argument-binding templates, and execution checks. Consequently, the reported improvements could partly result from these additional mechanisms rather than from the proposed use of procedural experience. Comparisons against stronger state-machine or scripted-controller baselines would help establish how much of the improvement comes specifically from SCC.

Q2: How much of SCC's improvement comes from procedural experience, as opposed to the additional execution machinery? Could the authors compare SCC against a controller with the same state representation, action constraints, argument validation, and repetition guards, but without dependencies or procedures derived from experience? Such an experiment would help determine whether the experience-derived representation provides value beyond a conventional state-aware execution harness.

Response: The core improvement mechanisms of SCC all stem from procedural experience. SCC uses procedural experience to determine whether manually defined soft and hard control rules are enabled. The channel ablations in the main paper examine the gains from this experience-driven control over the basic interface. Interface adaptation handles observation parsing, state recording, and action calls. With the same state representation, action constraints, argument validation, and repetition guards, None disables soft and hard control and therefore contains no trajectory experience:

Adding soft and hard control: Hybrid − NoneGain95% CI
TS mean score16.65[11.58, 22.01]
ALF success rate (percentage points)71.64[64.18, 79.10]
WS success rate (percentage points)9.80[6.90, 12.70]

W4: The results suggest that the benefits of hard control depend on the environment, but the paper does not sufficiently explain when restricting the model's action space is beneficial. If the state representation is incomplete or an action has effects that are not captured by the controller, hard control could prevent the model from exploring valid alternatives. A clearer characterization of the conditions under which hard control helps, hurts, or should defer to soft control would strengthen the framework's motivation.

Response: Hard control is suited to necessary operations whose objects are bound and execution conditions are clear. When the target has not been located or bindings across subgoals remain unresolved, the model continues searching and planning.

Adding the hard channel to Soft yields:

Environment / metricGain95% CI
TS mean score10.43[6.09, 15.11]
ALF success rate (percentage points)24.63[17.16, 32.84]
WS success rate (percentage points)0.70[−0.30, 1.70]

The per-task paired changes on ALF are:

ALF paired outcomeGames
Failure → success35
Success → failure2

Both types of improvement trajectories emerge within the context of rigidly controlled automated actions. The two forms of regressive trajectories, meanwhile, stem respectively from redundant searching by small-scale models and the erroneous selection of targets.

AuthorsOpenReview ↗

Response to Reviewer Xw19 - Part 3

Q3: What happens when the controller's state representation is incomplete or incorrect? Since hard control can restrict the model's available actions or execute actions directly, an incorrect state estimate could propagate into subsequent decisions. How does SCC detect and recover from these errors, and can the authors quantify performance as state observations become noisy, ambiguous, or unavailable?

Response:Manual inspection found no incomplete or incorrect controller state representations, so we cannot quantify performance under noisy, ambiguous, or unavailable state observations. SCC can nevertheless use execution feedback to detect and recover from erroneous behavior and states.

The following engineering mechanisms ensure that the controller's state representation is neither incomplete nor incorrect. SCC maintains state from public observations and execution feedback, leaving unobserved information unknown. When objects, arguments, or preconditions cannot be determined, the controller does not take over execution. The model continues exploring while the system checks state and handles fallback. Reviewing location and inventory records across 134 ALF trajectories found no inconsistencies with public feedback. Illegal or ineffective actions are handled through feedback checks and do not advance the task stage.

The interfaces and execution pipeline for the same ALF games were also checked with a scripted policy:

Engineering execution checkALF successes / gamesSuccess rate (%)
Complete environment-specific script134/134100.00

This result validates the evaluated execution paths. The audit identified no naturally occurring state-tracking errors, so no recovery rate for such errors was measured.

W3: The generalizability of the approach remains unclear. Although the paper evaluates SCC across three environments and reuses it with different language models, the controller itself relies on manually defined environment-specific structures, and the evaluated suites informed its development. Cross-model compatibility does not necessarily demonstrate that the framework can generalize to unseen tasks, new procedures, or environments without substantial additional engineering. This limits the strength of the claim that SCC provides a broadly applicable solution to unreliable state tracking in small language models.

Response: SCC reuses procedural experience and rules within the same environment, with objects and parameters dynamically rebound based on current observations; the primary experimental results thus represent a large-scale generalization from the development set to the test set. When transferring to a new environment, it is necessary to adapt observation parsing, action semantics, state fields, and outcome verification, and to construct a controller using experience gathered from that environment. The results for tasks not included in the experience-collection phase are as follows:

EnvironmentEvaluation tasksSCC result
TS42056.54 points
ALFWorld13482.09%
WebShop50032.60%

These results evaluate reuse on instances outside the experience sources within covered procedures.

Thank you for addressing my concerns, I do beleive my initial rating was justified, however with added evaluations and discussions provided by the authors I am more confident on my evalaution.

Reviewer_ovMKOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes State-Conditioned Control (SCC), which compiles trajectory experience into a shared procedural representation to improve small language model agents without updating their weights. SCC uses current observations to provide state-specific guidance, restrict available actions, and directly execute supported steps.

Critical strengths

S1. The paper addresses an important limitation of small language model agents: retrieving an appropriate procedure does not necessarily enable reliable execution. S2. The reported system-level improvements are substantial, particularly on ALFWorld. S3. The same experience store and controller are reused with Qwen3-4B and Gemma-3-4B-IT without further tuning. This provides useful evidence of compatibility across model backbones.

Critical weaknesses

W1. The major concern is the insufficient separation between system development and evaluation: Appendix A.1 states that the evaluated suites informed model selection and controller refinements. The results therefore lack an independent holdout and may reflect adaptation to the evaluation tasks.

W2. Unclear contribution of trajectory experience: The current ablations do not establish how much of the proposed system’s performance improvement actually comes from trajectory experience. The hard-control channel also includes manually designed guards that may independently improve task completion.

W3. Missing comparisons with closely related baselines: StateFlow and AWM are cited but not experimentally compared. Given SCC’s emphasis on state-dependent execution, comparisons with related workflow controllers would help establish its incremental value. Their absence limits the empirical support for the paper’s novelty and contribution.

Questions for authors

Please see weakness

1 comment
AuthorsOpenReview ↗

Response to Reviewer ovMK

Thank you for acknowledging the issues addressed in this paper, as well as the performance gains achieved by SCC when freezing small-scale models. Below, we address your comments by covering three aspects: (1) the distinction between development and evaluation tasks, (2) the contribution of trajectory experiences, and (3) a supplementary comparison with AWM and StateFlow. This will provide further clarification regarding our experimental setup, the sources of performance improvements, and how our approach relates to existing methods.

W1: The major concern is the insufficient separation between system development and evaluation: Appendix A.1 states that the evaluated suites informed model selection and controller refinements. The results therefore lack an independent holdout and may reflect adaptation to the evaluation tasks.

Response: We checked the archived development batches against the current evaluation task IDs. The portion discussed in the appendix was used only for interface debugging, with no data leakage. The task counts for the archived construction stage are:

EnvironmentTasks in archived development batchesEvaluation tasks
TS24420
ALFWorld24134
WebShop16500

TS and ALF use two development batches selected by task-family stratification and a fixed hash order. WS uses a fixed range of development goals. The current TS evaluation set excludes exact experience-source IDs, while ALF and WS use training sources and official evaluation sets. The development tasks are primarily used to adapt the adapter's interfaces. Experience is extracted from the development batches shown above, followed by testing on independent evaluation tasks.

W2: Unclear contribution of trajectory experience: The current ablations do not establish how much of the proposed system’s performance improvement actually comes from trajectory experience. The hard-control channel also includes manually designed guards that may independently improve task completion.

Response: Trajectories provide operation order, dependencies, and argument sources that are not specified by the interfaces or generic guards. We added ablations that retain the public interfaces and generic guards. The results show additional gains from this procedural information and the control mechanisms it drives. The adapter's parsing rules, soft and hard control rules, and execution templates are manually defined. Trajectory experience determines which control rules are enabled. Soft guidance uses the current stage to indicate the next step, while hard control uses dependencies and bindings to determine when to constrain or execute an action. Since stage guidance reads graph-node information, it is removed together with the graph-based procedure.

ConfigurationTS mean scoreALF success rate (%)
Public interfaces, state tracking, and generic guards43.3912.69
Full SCC56.5482.09
Gain and 95% CI+13.15 [8.00, 18.63]+69.40 [61.19, 77.61]

TS retains tool-return fields and candidate arguments, while ALF retains native observations and internal state tracking. Both retain the public interfaces and generic guards, jointly removing trajectory procedures and the guidance and execution that depend on them. The comparisons use the same 420 tasks and 134 games, respectively, and measure the combined contribution of procedural experience and control mechanisms.

W3: Missing comparisons with closely related baselines: StateFlow and AWM are cited but not experimentally compared. Given SCC’s emphasis on state-dependent execution, comparisons with related workflow controllers would help establish its incremental value. Their absence limits the empirical support for the paper’s novelty and contribution.

Response: We added comparisons with the related baselines AWM and StateFlow. SCC scores higher than AWM in all three environments. On ALF, it exceeds StateFlow by 2.24 percentage points and uses 27.45% fewer tokens per successful task.

MethodTS mean scoreALF success rate (%)WS success rate (%)
SCC (main experiment)56.5482.0932.60
StateFlow—79.85—
AWM38.6819.4026.80

The comparisons use frozen Qwen3-8B, the same tasks, and the same native-action budgets. As StateFlow uses hand-written workflows, we evaluate only the ALF workflow adapted by its authors; the other environments are not evaluated (—). AWM follows the authors' induction instructions, with a strong teacher constructing workflows from six successful source trajectories per environment. The 95% CI for SCC's ALF difference from StateFlow is [−6.72, 11.19], and tokens per successful task are 17.70k versus 24.40k.

Reviewer_rAPzOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper argues that small agent models with frozen weights often fail at local decisions even when they know the procedure. SCC compiles expert trajectories into short process graphs of steps, dependencies and argument sources. At run time, the harness uses them to give the model a hint about the current step, restrict its actions and execute steps it can fully resolve. On tool-use, household and web-shopping benchmarks, SCC beats four offline memory baselines, and the controller transfers to two other small models.

Critical strengths
  1. The gains for a frozen small model are large, especially on ALFWorld, and the same experience and rules carry over to two other small models. This shows how much the harness can matter for small local agents.

  2. The evaluation is transparent, which makes the claims checkable. The channel configurations share tasks and budgets, negative results are reported, and the main comparison is rerun without the overlapping task IDs.

Critical weaknesses
  1. The paper does not separate the effect of trajectory-derived experience from that of hand-written environment adapters, so it is unclear what drives the gains. This matters because turning trajectories into control is the paper's new part, while workflow extraction (Agent Workflow Memory) and state-machine control (StateFlow) already exist. The hand-written parts do much of the work. On ALFWorld, the soft channel alone, whose packet already contains fixed stage instructions, gives most of the gain. On ToolSandbox, every action mask observed under hard control is a termination guard. The memory baselines get none of these adapters, so table 1 compares a hand-engineered harness with text retrieval.

  2. The evidence does not yet support decision allocation as a general design principle. The evaluation is not held out: all three suites informed development, and on ToolSandbox almost all source tasks behind the graphs are in the evaluation set. Transfer is also unclear. The adapters are written per environment with no report of the effort. The method also needs parseable states and checkable steps, and its robustness to changed tools or layouts is untested.

Questions for authors
  1. How does an adapter-only control score, with the same parsers, state tracking, stage instructions and guards but no trajectory-derived graphs? How does a scripted policy do?

  2. On ToolSandbox, what does the no-control configuration score with only the termination guard added?

  3. How much effort did each adapter take? Can you show SCC on an environment or task family not used during development?

  4. Can the memory baselines get the same per-step state packet, or be run in their original online form?

5 comments
AuthorsOpenReview ↗

Response to Reviewer rAPz - Part 1

Thank you for acknowledging SCC’s effectiveness in enhancing the task-execution capabilities of smaller models, as well as the value of reusing experience and rules across different models. In response to your feedback, we provide a detailed breakdown of our method design and report additional experimental results, covering the following aspects: (1) the roles of trajectory experience and adapters; (2) the independent contribution of the "stop-protection" mechanism; (3) baseline comparisons involving shared state and augmented memory; and (4) the effort required for adaptation and task transfer.

Q1: How does an adapter-only control score, with the same parsers, state tracking, stage instructions and guards but no trajectory-derived graphs? How does a scripted policy do?

Response: Across the same 134 ALF games, the success rate is 12.69% when the graph-based process and dependency mechanisms are removed, compared to 82.09% for the full SCC (State-Condition-Constraint) framework. A script-only approach, tailored to specific tasks, achieves a success rate of 100.00%.

Phase guidance is generated based on graph nodes, pending dependencies, and object bindings. To evaluate this coupled mechanism, we removed the graph-based process, phase guidance, and dependency control, while retaining the common interfaces, state tracking, parsing, and general safeguards.

ALF ConfigurationSuccess Rate (%)
Without graph-based process and dependency mechanisms12.69
Full SCC82.09

This set of ablation experiments measures the combined contribution of the graph-based process, its associated guidance, and the execution mechanisms. The script-only approach does not invoke a model; instead, it relies on observable states and manually defined search rules to determine all actions:

StrategySuccessful ALF Games / Total GamesSuccess Rate (%)
Environment-specific full script134 / 134100.00

The successful completion of all 134 games confirms that the interfaces and execution chains within the tested tasks function correctly.

Q2: On ToolSandbox, what does the no-control configuration score with only the termination guard added?

Response: When only the graph-completion termination guard added, the average ToolSandbox score is 41.59; when only the generic repetition-stopping guard is enabled, the score is 41.63.

ConfigurationAverage TS Score
Graph-completion termination only41.59
Generic repetition-stopping only41.63
SCC56.54

The graph-completion safeguard monitors the completion status of a graph, disabling process guidance and automated execution; the generic repetition safeguard detects repeated invocations and lack of state change. All three configurations were tested using the same set of 420 problems. The full SCC mechanism yields an improvement of 14.94 points over the graph-completion safeguard alone (95% CI [10.11, 20.06]), indicating that the complete control mechanism provides benefits beyond those of individual stopping safeguards.

AuthorsOpenReview ↗

Response to Reviewer rAPz - Part 2

W1: The paper does not separate the effect of trajectory-derived experience from that of hand-written environment adapters, so it is unclear what drives the gains. This matters because turning trajectories into control is the paper's new part, while workflow extraction (Agent Workflow Memory) and state-machine control (StateFlow) already exist. The hand-written parts do much of the work. On ALFWorld, the soft channel alone, whose packet already contains fixed stage instructions, gives most of the gain. On ToolSandbox, every action mask observed under hard control is a termination guard. The memory baselines get none of these adapters, so table 1 compares a hand-engineered harness with text retrieval.

Response: The methodological contribution of SCC lies in its use of trajectory-based processes to drive state-conditioned "soft guidance" and "hard control" atop an environment adapter framework. We validate this design through ablation studies, comparisons with shared-state Action Masking (AMD), and evaluations against AWM/StateFlow.

The environment adapter handles the parsing of observations, state tracking, and action execution. Rules and execution templates for both soft guidance and hard control are manually defined, with their activation determined by trajectory-based experience. Specifically, the Trajectory-based Selector (TS) extracts actions, parameter sources, and sequential dependencies from successful task executions; the Action-Logic Framework (ALF) preserves operational phases from successful demonstrations while replacing specific objects with placeholders (slots). Soft guidance utilizes the current step, while hard control leverages dependencies and bindings derived from the same process. These trajectory-based experiences dictate whether the manually defined soft or hard control rules are triggered. Our ablation experiments demonstrate the incremental gains provided by this experience-driven control. Using the same underlying model, task settings, and environment adapter, we compare configurations where soft and hard controls are disabled ("None") versus enabled individually ("Soft" and "Hard"):

ConfigurationTS Average ScoreALF Success Rate (%)WS Success Rate (%)
None (Soft/Hard control disabled)39.8810.4522.80
Soft (Soft guidance only)46.1157.4631.90
Hard (Hard control only)55.2367.9127.70
SCC (Combined soft & hard control)56.5482.0932.60

Both channels provide performance gains over the base environment adapter. In the TS configuration, the observed action masks serve as termination safeguards, while the hard control channel additionally incorporates automated action execution. To ensure alignment with publicly available information, we have incorporated mechanisms—along with corresponding adapters—that allow the AMD (Agent-based Modular Decomposition) framework to progressively access tool outputs, bindable parameters, and the states of observed objects. The full system comparison is presented below:

MethodTS Average ScoreALF Success Rate (%)WS Success Rate (%)
SCC56.5482.0932.60
StateFlow—79.85—
AWM38.6819.4026.80

Comparisons are based on the use of a frozen Qwen3-8B model and a shared, native action budget. StateFlow retains the original workflows provided by its authors; it was not evaluated in the other environments. AWM utilizes the authors' summarized instructions, with workflows constructed by a strong teacher model based on six successful demonstration trajectories per environment. SCC outperforms AWM across all three environments. On the ALF benchmark, SCC surpasses StateFlow by 2.24 percentage points (95% CI [−6.72, 11.19]) while reducing the token cost per successful task from 24.40k to 17.70k—a decrease of 27.45%.

Q4: Can the memory baselines get the same per-step state packet, or be run in their original online form?

Response:We added a control experiment in which AMD is provided with the same step-by-step state information. The "shared state" version achieves a score of 51.26 on TS, while SCC achieves 56.54, with a 34.08% reduction in tokens per task.

MethodTS Avg. ScoreTS Tokens/Task (k)ALF Success Rate (%)ALF Tokens/Task (k)
AMD + Decomposition42.5914.9818.6626.58
AMD + Decomposition + Shared State51.266.9716.4225.42
SCC (Main Experiment)56.544.5982.0914.53

The step-by-step state information includes tool outputs, bindable parameters, and observed objects, supplemented by mechanisms to prevent repetition; AMD handles both the decomposition and action selection. The difference in TS score between SCC and the "shared state" AMD variant is 5.28, with a 95% CI of [−2.21, 12.91].

AuthorsOpenReview ↗

Response to Reviewer rAPz - Part 3

W2: The evidence does not yet support decision allocation as a general design principle. The evaluation is not held out: all three suites informed development, and on ToolSandbox almost all source tasks behind the graphs are in the evaluation set. Transfer is also unclear. The adapters are written per environment with no report of the effort. The method also needs parseable states and checkable steps, and its robustness to changed tools or layouts is untested.

Q3: How much effort did each adapter take? Can you show SCC on an environment or task family not used during development?

Response: Developing the TS adapter requires 64.7 minutes—a one-time investment for this category of tasks. For comparison, when executing the same set of TS tasks, it takes an average of 390.58 seconds per task for a human instructor, whereas students using the SCC require only 4.48 seconds per task; this initial investment is amortized over subsequent tasks. While the SCC can generalize to tasks within the same environment that were not encountered during development, it cannot generalize directly across different environments. A new environment requires the reimplementation of observation parsing, action semantics, and interface adaptation, followed by the construction of an SCC based on experience within that specific environment. Our experimental results for tasks within the same environment—excluding those used during development—are as follows:

EnvironmentNumber of Evaluation TasksSCC Results
TS42056.54 points
ALFWorld13482.09%
WebShop50032.60%

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of the Rebuttal

We thank all reviewers for their constructive feedback, and the ACs and PCs for organizing the review process. We appreciate the reviewers' recognition of the importance of the problem studied in this work (rAPz, ovMK, Xw19, and AqVb), as well as their positive assessment of SCC's practicality for frozen small models, soft and hard control mechanism, evaluation across three environments, and cross-model reuse. Based on the original manuscript, the rebuttal, and the revised content, we summarize the main contributions of the paper and the key clarifications made during the discussion.

Our main contributions are:

  1. We introduce a control-theoretic mechanism for state-conditioned decision allocation, which assigns task-relevant execution responsibilities between a frozen small language model and an external harness according to the current state.

  2. We compile trajectory experience into procedures, dependencies, and argument bindings, and use the same experience representation to drive soft guidance and hard control. This transfers part of the local decision burden from the small model to the harness while reducing task execution cost.

  3. We systematically evaluate this mechanism on ToolSandbox, ALFWorld, and WebShop, combining cross-model experiments, control-channel ablations, a shared-state baseline, comparisons with related methods, and cost analysis to study its performance, attribution, and scope of applicability.

In response to the reviewers' comments, we added and clarified the following:

  1. The roles of trajectory experience and environment adapters (rAPz W1/Q1, ovMK W2, AqVb W1/Q1). We added the ALFWorld adapter-only control, the ToolSandbox guard-only control, None/Soft/Hard/SCC channel ablations, and an AMD comparison with the same publicly available state information. These experiments separate the effects of interface parsing, generic termination protection, trajectory-derived procedural information, and execution control. Reviewer rAPz confirmed that the adapter-only and guard-only comparisons address the core attribution concern in W1: the main gains come from the trajectory-derived graph structure rather than from the adapter or termination protection itself.

  2. Related-work and fairness comparisons (ovMK W3, AqVb Q3, rAPz Q4). We added comparisons with AWM and StateFlow, as well as an AMD variant with student-side decomposition restored. The cost accounting includes shared state, auxiliary calls, and the native action budget. SCC achieves the highest point estimate among the evaluated baselines in all three environments while reducing task execution cost.

  3. Methodological principle and scope of applicability (Xw19 W1/Q1, W3/Q2, rAPz W2/Q3, ovMK W1). We formalize the trigger conditions for hard control: the harness takes over only when the procedure matches, object and argument bindings are unique, the action is legal, its preconditions hold, and sufficient budget remains; otherwise, the model continues searching and making decisions. We also clarify that our claim concerns procedural reuse within an environment and reuse across models. A new environment requires a new adapter and compilation of that environment's experience.

  4. Cost, execution feedback, and reproducibility (AqVb Q4, Xw19 W4). We report the one-time construction cost of the TS adapter, the cost of collecting teacher experience and its amortization range, and additional details on execution feedback, state checks, and fallback mechanisms. The implementation, experimental protocols, and supplementary results are available in the anonymous repository.

The discussion does not change the research question of the paper: we study how reusable trajectory experience can be transformed into state-conditioned execution-authority allocation, transferring part of the reasoning and planning burden to the harness to improve the reliability and inference efficiency of small-model agents. The method, the three-benchmark main experiments, cross-model reuse, channel ablations, related-work comparisons, and cost analysis jointly support the paper's central conclusions. Reviewer Xw19 stated that the additional experiments and discussion increased confidence in the paper, and reviewer rAPz confirmed that the new attribution comparisons addressed the core W1 concern.

We believe these changes address the reviewers' concerns and strengthen the paper. If there are any remaining questions, we are happy to answer them.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.