acceptodds
Under review as a conference paper at ICLR 2027

MaRePID: Multi-Agent LLM Reasoning via Distributed PID Regulation

Abstract

Multi-agent large language model (LLM) systems increasingly solve complex tasks through multi-round reasoning, where corrections from one agent can influence the subsequent reasoning of others. Such evolving interactions make it challenging to determine how feedback should guide corrections throughout the reasoning process. We introduce **MaRePID**, an inference-time framework that regulates multi-agent LLM reasoning using distributed proportional–integral–derivative (PID) control. For each agent, MaRePID maintains a bounded control state updated from evaluator-derived feedback and neighboring control summaries, and maps the resulting state to textual directives that steer subsequent reasoning. By jointly accounting for the current mismatch, its accumulated history, and its recent change, MaRePID dynamically adjusts prompt guidance while capturing interactions among agents. We further introduce prediction-triggered sensing to determine when new evaluator feedback is necessary, reducing unnecessary evaluator queries. Across MultiAgentBench, AgentWebBench, MATH, and BigCodeBench, the full-sensing, always-update variant of MaRePID consistently outperforms the evaluated fixed and adaptive baselines, achieving an improvement of up to 18.3 points over the base multi-agent system on AgentWebBench. These results demonstrate that MaRePID enables effective inference-time regulation of multi-agent reasoning without modifying model parameters or the underlying communication protocol.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Multi-Agent LLM, LLM Reasoning, Distributed PID Control, Inference-Time Regulation

Reviews

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

MaRePID adds a bounded numerical controller to a frozen multi-agent LLM system. Process-evaluator scores and neighboring command states define an error; proportional, integral, and derivative terms produce an offset from an anchor command, which is clipped and converted into discrete prompt directives. The paper reports improvements on MultiAgentBench, MATH, BigCodeBench, and AgentWebBench, together with feedback-replay, PID-component, validation-budget, and optional sensing experiments. Its analysis derives command bounds, local affine dynamics, a scalar stability condition, and a tracking bound for the reference filter.

Critical strengths
  1. The numerical interface makes the adaptation more explicit and inspectable. Separating evaluator measurements, calibrated error, bounded command state, and discrete prompt directives gives a concrete alternative to unconstrained textual revisions. The formulation accounts for dimensions, one-round measurement delay, integral clipping, and the fact that a numerical command change may leave the text unchanged.

  2. The reported controls target relevant alternatives. Table 2 compares feedback regulation with replay, shuffled feedback, and a fixed dynamic schedule; Table 4 removes individual PID terms; Table 6 compares sensing against random skipping at matched query counts. These are useful tests of whether feedback timing and temporal memory contribute, and the reported results are promising if the experimental conditions can be established.

Critical weaknesses
  1. The central empirical claims cannot be adequately assessed from the supplied experimental specification. Table 1 does not identify which of the three named backbones produces its scores or how results are aggregated. Test-set sizes, evaluator identity and rubric, reference-generation procedure, prompt templates, and the settings underlying the different aggregate scores in Tables 2–4 are not supplied. Appendix E largely refers back to Section 4, rather than providing these details; Appendix G names robustness conditions without reporting their outcomes. Although paired bootstrap intervals and Holm correction are promised, corresponding intervals or corrected test results are not shown. This matters especially for small differences such as 77.5 versus 77.4 in Table 3, and for reproducing the control interface itself.

  2. The main text overstates what is established about closed-loop stability. Section 3.4 says Appendix C establishes stability of the nonlinear, quantized LLM system. What is shown is boundedness by clipping, conditional stability of a local affine model, and stability of a separate reference filter. Appendix C.3 explicitly identifies a unit eigenvalue in the unrestricted affine model; C.6 reports that the selected gains fail the scalar condition under its sensitivity substitution. These qualifications do not prove the deployed system unstable, but they mean the analysis does not establish its convergence or stable task behavior. The paper needs either a narrower claim or evidence that the relevant accessible dynamics satisfy the required conditions. Bounded prompts alone do not supply that evidence.

Questions for authors
  1. Please identify the backbone, evaluation sample counts, score aggregation, evaluator/model rubric, reference-generation and directive templates, and baseline inference budgets for each result table. What inputs can the evaluator and reference generator access, including any reference answers or tests? Are the promised per-backbone results, paired intervals, and robustness outcomes available? These details could substantially change confidence in the reported advantages.
  2. Which specific stability conclusion is intended for the deployed controller? Is there an identified accessible network model or an empirical tracking/convergence test that supports it, beyond clipping bounds and the conditional scalar analysis? Please reconcile the main-text claim with the qualifications in C.3 and C.6.
4 comments
AuthorsOpenReview ↗

Response to Reviewer K8pa (1/3)

Thank you for a precise review and for separating what Appendix C proves from what Section 3.4 claimed. In short: (1) Appendix E now specifies every result table, the evaluator, the reference rule, inference costs and paired statistics. (2) After Holm correction, MaRePID is on par with the strongest baseline in every column of Table 1 except AgentWebBench, where it leads by 5.7 points. (3) The stability claim is limited to what Appendix C proves, and Appendix C.11 adds an empirical tracking test.

Weaknesses

1. Experimental specification.

All result tables use Qwen3-235B-A22B with seeds 17, 41 and 89, three agents, six rounds, full sensing and an update every round. Appendix E.1 assigns each table to an evaluation family.

TableFamilyTest tasksScore
1MAIN160 / 134 / 116 / 500 / 500 / 190Official benchmark score, mean over seeds
2ISOLATION160 MAB-CodingLenient task score
3, 4, 5CONTROL160 MAB-CodingLenient task and coordination score

ISOLATION and CONTROL reuse the 160 MAB-Coding tasks of Table 1 with a lenient score that omits the budget term. This raises scores by 2.4 to 4.9 points depending on the method, so MaRePID scores 74.6 in Table 1, 78.3 in Table 2 and 77.5 in Tables 3 to 5. ISOLATION and CONTROL were run separately and differ in the agents' maximum response length, which changes the accumulated history and token usage (175.2k vs 188.2k tokens per MaRePID task, Appendix E.4). We compare methods only within a family. Evaluation subsets are fixed by a hash-based rule (E.1). The first 60 IDs of each family form the validation set and are never used for testing.

2. Paired statistics.

Appendix E.5 reports a task-paired bootstrap (10,000 resamples, 95% percentile CI) with Holm correction over 11 comparisons against the strongest baseline in each column.

ComparisonBaselinenMaRePIDBaselineΔ95% CIHolm p
MAB-Coding TSGEPA16074.673.7+0.9[−0.148, 1.965]0.703
MAB-Coding CSHiveMind16071.971.6+0.3[−0.634, 1.235]1.000
MAB-Research TSTextGrad13476.075.8+0.2[−0.843, 1.266]1.000
MAB-Research CSTextGrad13469.868.6+1.2[0.202, 2.207]0.192
MAB-Database TSHiveMind11665.064.6+0.4[−0.910, 1.753]1.000
MAB-Database CSMIPROv211672.871.2+1.6[0.308, 2.943]0.192
MATHHiveMind50083.182.3+0.8[−0.658, 2.256]1.000
BigCodeBenchGEPA50054.654.0+0.6[−1.337, 2.562]1.000
AgentWebBenchGEPA19078.572.8+5.7[3.910, 7.500]< 0.002
Table 3 taskTextGrad16077.577.4+0.1[−1.117, 1.275]1.000
Table 3 coordinationHiveMind16075.774.8+0.9[−0.001, 1.795]0.424

Only the AgentWebBench difference survives Holm correction, and the abstract and Section 4.2 now claim parity elsewhere. On AgentWebBench, MaRePID leads GEPA and Feedback-only in all four task families by 3.7 to 8.2 points, and all eight 95% CIs lie above zero.

AuthorsOpenReview ↗

Response to Reviewer K8pa (2/3)

Weaknesses (continued)

3. Stability claim.

Under stated assumptions, Appendix C proves three results. Commands and integral states stay in fixed boxes for any sensing and actuation decisions (Prop. C.6). The reference filter tracks its input with a geometric bound (Lemma C.7). A scalar local affine surrogate with inactive clipping is stable if and only if h(2K_P + K_I + 4K_D) < 2 (Thm. C.5). These results do not establish convergence or stability of the deployed nonlinear, quantized LLM loop. Section 3.4 now states exactly this and points to the tracking test in C.11. Section 5 is revised in the same way. Each run has six rounds and at most five command updates, so the method relies on bounded behaviour over a short horizon. Prop. C.6 guarantees this for the requested commands, not for the LLM's realized behaviour.

Questions

Q1a. Evaluator and its inputs.

The process evaluator is Qwen3-235B-A22B with thinking disabled, greedy decoding and a 768-token output cap. It returns task quality, constraint satisfaction and coordination in [0, 1]. Its system and user prompts are given verbatim in E.2. It receives six fields on every benchmark: TASK, ROLE, CONSTRAINTS, CURRENT_OUTPUT, PERMITTED_HISTORY and PUBLIC_OBSERVATIONS. None of them contains reference answers, hidden tests or other grading information, and BigCodeBench tests are used only for final scoring. Over 400 repeated scorings its standard deviation is 0.021 (C.3).

Q1b. Reference generation and directive templates.

The reference generator is a deterministic rule shared by all benchmarks. For each evaluator coordinate q, r_q = min(1, y_q^last + g_q) with g = (0.08, 0.04, 0.05). It makes no model call and sees no grading information. Eq. (3) then aligns references along the communication graph, and ζ_i clips the result to [0, 1] to give y_des. Section 3.2 now states this rule. E.3 gives the directive templates φ and the prompt composition Γ_i for every benchmark, and Table 8 now includes the AgentWebBench interface.

Q1c. Baseline inference budgets.

E.4 lists agent generations, evaluator calls, input and output tokens and wall-clock time per task for every method. In the MAIN family every multi-agent method makes 18 agent generations per task. MaRePID, Feedback-only and HiveMind also make 18 evaluator calls. MaRePID uses 189.8k tokens and 171 s per task, close to Feedback-only (188.8k, 173 s) and HiveMind (186.2k, 177 s). The offline optimizers GEPA, TextGrad and MIPROv2 make no test-time evaluator calls and use 124k to 132k tokens and 107 s to 109 s. Validation budgets are given in Table 3.

Q1d. Per-backbone results, paired intervals and robustness.

E.6 reports Table 1 for Qwen3-8B and DeepSeek-V4 with the same interface and gains. MaRePID improves over No-PID in every column on every backbone. Its AgentWebBench advantage over the strongest baseline is 4.8 points on Qwen3-8B and 4.6 on DeepSeek-V4, against 5.7 on Qwen3-235B-A22B. Across the 27 backbone-column cells, MaRePID is best or tied in 22 and below the strongest baseline in 5, by 0.2 to 1.7 points (largest: MATH on DeepSeek-V4). Paired intervals are in Weakness 2 above. Appendix G reports all robustness conditions against Feedback-only. The advantage holds under evaluator noise (+1.9 at SD 0.02, +0.6 at SD 0.05) and with two or five agents (+1.6 each). It nearly vanishes with a weaker evaluator (+0.2) and reverses under measurement delay (−0.3 for one round, −1.4 for two). Section 5 now states that the method relies on an accurate and timely evaluator.

AuthorsOpenReview ↗

Response to Reviewer K8pa (3/3)

Questions (continued)

Q2a. Intended stability conclusion.

For the deployed controller we claim only three things. Requested commands and integral states stay in fixed boxes for any LLM behaviour and any sensing or actuation decisions (Prop. C.6). The reference filter tracks its input with a geometric bound (Lemma C.7). A scalar local affine surrogate with inactive clipping is stable if and only if h(2K_P + K_I + 4K_D) < 2 (Thm. C.5). We do not claim convergence or stability of the deployed loop.

Q2b. Network model and empirical evidence.

We agree that bounded prompts alone do not show stable task behaviour. The revision adds an empirical test (C.11) on the logged CONTROL runs (160 tasks, 3 seeds, 3 agents, 1,440 agent runs, 28,800 coordinate updates). The mean tracking mismatch |y_des − y| falls from 0.0721 in round 1 to 0.0441 in round 6 (−39%), and the mean coordinate |e_i| falls from 0.0408 to 0.0250. No update reaches the offset saturation bound (0 of 28,800). Update directions reverse at least once in 64.4% of agent runs, which matches the mild oscillation the scalar model predicts for the most sensitive actuators. In 60.4% of coordinate updates the quantized directive level does not change. With five updates per run we present this as descriptive evidence, not as a convergence proof.

We have not identified the full local network model. That requires signed cross-coordinate and cross-agent sensitivities, while our finite-difference runs (C.5) perturbed one directive coordinate at a time. C.3 now states this limitation.

Q2c. Reconciling the main text with C.3 and C.6.

C.3. The unit eigenvalue belongs to directions v with Hv = 0. These are command changes the evaluator does not register, which exist because D_i has rank at most 3 < k = 4. Along these directions the error is zero, so they form a continuum of equilibria, not a growing mode. Residual inputs can still move the state along them without a restoring force, and the command box and integral clip of Prop. C.6 bound this movement. C.3 now says so explicitly.

C.6. You are right that with g = L_s at the 90th-percentile sensitivity, the selected non-root gains (0.50, 0.25, 0.08) violate the scalar condition in all four settings. The revised C.6 adds three facts.

  1. For non-root agents the condition is h < 2/1.57 ≈ 1.274, i.e. L < 1.457. The median sensitivities in Table 9 (0.87 to 1.21) satisfy it in all four groups, with spectral radius 0.84 to 0.89. In Research, Coding and Database the threshold lies above the 75th percentile, and in MATH it lies between the median and the 75th percentile.
  2. Root agents (gains 0.30, 0.09, 0.048) require h < 2/0.882 ≈ 2.27 and satisfy it even at the 90th percentile (at most 1.83).
  3. The substitution g = L_s is conservative in magnitude. L_s is the norm of the change across all three evaluator coordinates, while g uses one coordinate times its calibration coefficient (0.62 to 0.91).

The scalar surrogate therefore predicts local stability for typical actuators and possible oscillation for the most sensitive ones, most likely in MATH. We now present this as a limitation, not a guarantee. C.12 also checks the response sign the scalar model assumes. 18 of 20 directive coordinates respond in the intended direction, and the two exceptions in MATH are discussed in our response to Reviewer Fqec.

Thank you again for your review. We would be grateful to know whether our response and the revised PDF address your concerns, and we are happy to clarify anything further before the discussion period ends.

Reviewer_FqecOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes MaRePID, a distributed PID-based framework for regulating multi-agent LLM reasoning through inference-time feedback. The key idea is to formulate multi-round agent collaboration as a closed-loop control process, where evaluator feedback is used to adjust agents' reasoning directives over time.

MaRePID maintains a control state for each agent and updates it using proportional, integral, and derivative terms that capture current errors, accumulated errors, and recent changes. The framework also incorporates neighboring agents' control states to support distributed coordination. Additionally, a prediction-triggered sensing mechanism is introduced to reduce unnecessary evaluator queries.

Experiments across MultiAgentBench, MATH, BigCodeBench, and AgentWebBench demonstrate improvements over several fixed and adaptive baselines. The authors also provide feedback-isolation experiments, PID component ablations, and sensing-efficiency analyses to evaluate the proposed mechanisms.

Critical strengths

S1. An interesting and relatively novel perspective on feedback regulation for multi-agent reasoning.

The paper introduces a structured closed-loop control perspective by applying distributed PID principles to multi-agent LLM reasoning. Instead of relying solely on fixed prompts or unstructured textual feedback, MaRePID explicitly incorporates current errors, accumulated errors, and error trends to adapt reasoning directives across rounds. The additional consideration of neighboring agents' control states provides a meaningful extension to collaborative reasoning settings.

S2. Encouraging experimental results with useful mechanism validation.

The authors evaluate MaRePID across multiple reasoning and collaboration benchmarks and report improvements over several fixed and adaptive baselines. In particular, the comparisons with feedback-only and open-loop alternatives, together with PID component ablations, provide useful evidence for the effectiveness of the proposed regulation mechanism. The prediction-triggered sensing strategy also demonstrates potential for reducing evaluation costs.

Critical weaknesses

W1. The connection between PID control and actual LLM reasoning behavior remains insufficiently established.

Although the paper models multi-agent reasoning as a closed-loop control process, the PID controller operates on numerical variables that are converted into textual directives, rather than directly controlling the underlying reasoning states of LLMs. The relationship between these directives and actual model behavior can be highly nonlinear, stochastic, and task-dependent, making the applicability of classical PID assumptions unclear. The paper provides boundedness and local stability analyses, but their implications for real LLM reasoning dynamics remain limited. In particular, some selected controller parameters do not satisfy the derived local stability conditions under the scalar sensitivity settings examined in the appendix. While the empirical improvements are encouraging, the current evidence does not fully establish whether they arise from reliable feedback-control properties rather than heuristic dynamic prompt adjustment.

W2. Strong dependence on task-specific control interfaces limits the demonstrated generalizability.

MaRePID relies heavily on the process evaluator, reference generator, and mapping from numerical control variables to textual directives. These components require task-specific choices of control dimensions, targets, and directive ranges, involving substantial manual design and calibration. Although the paper provides configuration details and encouraging results, it remains unclear how systematically these interfaces can be constructed for new tasks or agent frameworks. Furthermore, improvements over the strongest existing baselines are relatively modest on some benchmarks. The current evaluation therefore provides limited evidence that the approach can generalize reliably without extensive task-specific tuning.

Questions for authors

Q1. Relationship between PID control and actual LLM behavior.

Could the authors clarify whether the numerical control variables have a consistent and predictable relationship with actual LLM reasoning behavior? In particular, how should we interpret the selected controller parameters that fall outside the derived local stability conditions under some scalar sensitivity settings? To what extent does the theoretical analysis explain the observed empirical improvements?

Q2. Design and generalizability of the control interfaces.

How are the process evaluator, reference generator, and directive mappings designed and calibrated? When applying MaRePID to new tasks, models, or agent workflows, how much manual redesign is required? Can the authors provide evidence of generalization with limited task-specific tuning?

Q3. Independent benefits of PID over simpler feedback methods.

Although the ablations support the effectiveness of the full PID controller, the improvements over strong baselines are relatively modest on some tasks. Could the authors clarify what consistent advantages the integral and derivative components provide over simpler adaptive feedback rules? How do these benefits compare with the additional evaluation and control overhead?

4 comments
AuthorsOpenReview ↗

Response to Reviewer Fqec (1/2)

Thank you for recognizing the closed-loop perspective and the mechanism-validation experiments. In short: (1) We use the PID law as a bounded and inspectable update rule, not as a model of the LLM, and Table 2 is our main evidence that the gains come from feedback. (2) Interface design is manual and now documented in Appendix E.3, while the gains and the reference rule are shared by all benchmarks. (3) The integral and derivative terms add 2.4 and 1.3 points over P alone without extra LLM calls.

1. PID control and actual LLM behaviour (W1, Q1).

We agree that the map from directive to behaviour is nonlinear, stochastic and task-dependent, and we do not model the LLM as a linear plant. MaRePID uses the PID law as a bounded update rule on a numerical directive state. P reacts to the current shortfall, I to persistent shortfall and D to its latest change. Sections 1 and 5 now say this.

Directives do affect behaviour. Perturbing one directive coordinate by 0.1 moves the evaluator measurement with median normalized sensitivity 0.87 to 1.21 across actuator groups (Table 9). New Appendix C.12 reports the Spearman correlation between each directive level and the evaluator score on its calibrated axis. For 18 of 20 coordinates the response is monotone in the intended direction (ρ 0.68 to 0.86). The two exceptions are in MATH, symbol accuracy (ρ = −0.369) and the binary consensus threshold (ρ = −0.327). These two directives respond in the opposite direction, and Section 5 lists their redesign as part of the interface design cost.

Our case for feedback rests on Table 2, not on Appendix C. Open-loop replay applies directive sequences that MaRePID produced on validation trajectories without feedback and reaches 72.9. Shuffled feedback keeps the format and frequency of feedback but breaks its timing and reaches 74.0. A fixed dynamic schedule reaches 71.4, and MaRePID reaches 78.3. These controls keep the directive vocabulary and remove only the link between feedback and directive. Table 10 points the same way. Removing dynamic feedback lowers the CONTROL task score from 77.5 to 70.4, close to No-PID (70.3), and removing the process evaluator gives 71.1.

On the gains outside the stability region, the scalar analysis in C.6 uses the 90th-percentile sensitivity. At the median sensitivity of every actuator group the selected non-root gains satisfy Theorem C.5, with spectral radius 0.84 to 0.89 against 1.006 to 1.173 at the 90th percentile. Root agents satisfy it even at the 90th percentile. In the logged runs (C.11) no update saturates and the tracking mismatch falls by 39% over five updates, while 64% of agent runs reverse their update direction at least once.

The theory is not meant to explain the accuracy gain. It guarantees that the controller keeps directives inside a calibrated box whatever the LLM does and shows when the local loop would oscillate. The empirical case for feedback regulation is Table 2 and the ablations in Table 4.

AuthorsOpenReview ↗

Response to Reviewer Fqec (2/2)

2. Design and generalization of the control interfaces (W2, Q2).

E.3 now gives the design procedure used for every benchmark. (1) Choose four directive dimensions that the rubric rewards or penalizes, each with an integer range and a one-sentence template. (2) Assign each dimension to the evaluator axis it should move, by hand from the rubric, and confirm the assignment with single-coordinate perturbations. (3) Choose the nonzero coefficients of D_i by search on 60 validation tasks per family. (4) Choose the anchor c_i(0) by a 0.01 grid search on the same tasks. Steps 1 and 2 are manual. Steps 3 and 4 use only validation tasks, which are excluded from evaluation. The five interfaces took 40.3 person-hours in total, 7.1 to 9.0 hours per family, of which 2.7 to 3.4 hours were calibration and checking.

Only the four directives, their ranges and templates, D_i and the anchor are task-specific. The evaluator axes, the reference rule, the PID gains and α, γ, β_r, u_max and I_max are shared by all benchmarks. The gains come from one 320-tuple validation search, and the five best tuples differ by at most 0.4 test points (C.6).

On new tasks, BigCodeBench reuses the MAB-Coding interface without change (Table 8), and MaRePID raises Pass@1 from 45.0 to 54.6 over No-PID. On new models, the per-backbone Table 1 in E.6 keeps the interface and gains fixed. MaRePID is above No-PID in every column on every backbone, by 9.2, 9.2 and 10.6 points on MAB-Coding task score (Qwen3-8B, Qwen3-235B-A22B, DeepSeek-V4) and 8.7, 9.6 and 9.3 on BigCodeBench. Against GEPA it is +2.3, +0.9 and +1.6 on MAB-Coding and −0.3, +0.6 and 0.0 on BigCodeBench. The gain from control carries over without retuning, and the ranking against the strongest optimizer varies by backbone and task. On new workflows, Appendix G runs teams of two and five agents with the same interface, and MaRePID stays 1.6 points above Feedback-only in both.

Outside AgentWebBench, the margin over the strongest baseline is 0.2 to 1.6 points and is not significant after Holm correction. On AgentWebBench the margin is 5.7 points (95% CI [3.910, 7.500]) and holds in all four task families. The revised text claims parity on most benchmarks and an advantage on AgentWebBench.

3. What I and D add over simpler rules, and at what cost (Q3).

Table 4 already contains the two common simple rules. P only, c(t+1) = c(0) + K_P e(t), reaches 73.5. With inactive clipping, I only equals the incremental rule c(t+1) = c(t) + K_I e(t) and reaches 71.8. Full PID reaches 77.5. Adding I to P gives +2.4 (75.9) and adding D to P gives +1.3 (74.8). D cannot be replaced by stronger integral action, since P+I with K_I doubled reaches 75.3. P+I already exceeds Feedback-only (74.9), and the full controller adds a further 1.6 points.

On AgentWebBench, splitting the 190 tasks into terciles by MaRePID's final |I| gives gains over GEPA of +1.1, +4.8 and +11.1, and over Feedback-only of −0.1, +6.3 and +11.4. We report this as an exploratory association, not a causal test.

The PID update is a few vector operations per agent per round and adds no LLM calls. Its 18 evaluator calls per task match Feedback-only and HiveMind. In the MAIN family MaRePID uses 189.8k tokens and 171 s per task, close to Feedback-only (188.8k, 173 s) and HiveMind (186.2k, 177 s). Prediction-triggered sensing cuts evaluator calls to 11.5 at a cost of 0.5 points and beats random skipping at the same budget (Table 5, 77.0 vs 75.9). The offline optimizers make no test-time evaluator calls and use about two thirds of MaRePID's tokens and time (E.4).

Thank you for your response!They substantially address my main concerns, and I would like to raise my rating from 2 to 3.

Thank you for reading our response and for raising your rating. The clarifications on interface design, the feedback controls and the contribution of the I and D terms are now part of the revised paper and will stay in the final version. We are happy to answer any further questions.

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

The paper presents MaRePID, an inference-time controller for multi-agent LLM reasoning. Each agent gets numerical feedback on task quality, constraint satisfaction, and coordination. A bounded PID update combines this feedback with the control states of neighboring agents. MaRePID then turns the result into text instructions for the next reasoning round. Tests cover MultiAgentBench, MATH, BigCodeBench, and AgentWebBench. The comparisons include static prompts, adaptive prompt optimizers, and feedback controls. The paper also tests PID ablations and an optional sensing mechanism that reduces evaluator calls.

Critical strengths
  1. Table 1 covers collaborative tasks, math, code, and web tasks. The AgentWebBench score rises from 60.2 to 78.5, while MAB-Coding goes from 65.4 to 74.6. Gains across these tasks make the controller worth studying.

  2. MaRePID scores 78.3 in Table 2. Open-loop replay reaches 72.9, and shuffled feedback reaches 74.0. These comparisons suggest that responding to current feedback helps improve performance.

  3. Performance drops when individual PID terms are removed (Table 4). This supports the PID design.

Critical weaknesses
  1. Section 4.1 lists three backbones. Table 1 does not say which produced the results or how results from different backbones were combined. This makes the main evaluation setup unclear.

  2. The method depends on an evaluator and a reference generator, but their models, prompts, and target-generation rules are missing. Table 9 gives ranges and calibration matrices. Appendix E does not provide the missing details either.

  3. MaRePID scores 77.5 and TextGrad scores 77.4 in Table 3. The paper specifies a bootstrap procedure but gives no confidence intervals for this comparison.

Questions for authors
  1. Which backbone and test sets were used for Tables 1–4? How are the evaluator scores and desired references obtained? Please give the task counts and explain the score definitions. Include paired confidence intervals for comparisons with the strongest adaptive baselines. These details matter for judging the gains.

  2. C.6 gives calculations for the selected gains. What supports the stability claim for the implemented nonlinear system? Does the intended guarantee only cover bounded commands and conditional stability of a local surrogate?

2 comments
AuthorsOpenReview ↗

Response to Reviewer juVR

Thank you for the careful review. In short: (1) All result tables use Qwen3-235B-A22B with three seeds, and Appendix E.6 adds Table 1 for the other two backbones. (2) Appendices E.2 and E.3 give the evaluator model and prompts and the deterministic reference rule. (3) The Table 3 comparison is parity, and the stability guarantee covers only bounded commands and a local surrogate, as you suggest.

Weaknesses

1. Backbone for Table 1.

Table 1 reports Qwen3-235B-A22B with seeds 17, 41 and 89. No numbers are averaged across backbones, and every result table caption now names its backbone. For Qwen3-8B and DeepSeek-V4, Appendix E.6 reports the full Table 1 with the same interface and gains. MaRePID improves over No-PID in every column on every backbone. Its AgentWebBench advantage over the strongest baseline is 4.8 and 4.6 points, against 5.7 on Qwen3-235B-A22B.

2. Evaluator and reference generator.

The evaluator is Qwen3-235B-A22B with thinking disabled, greedy decoding and a 768-token output cap. Its system and user prompts are given verbatim in E.2. It scores task quality, constraint satisfaction and coordination on every benchmark, with task-specific milestone and constraint checks. The reference generator is a deterministic rule shared by all benchmarks, r_q = min(1, y_q^last + g_q) with g = (0.08, 0.04, 0.05). The target y_des is this reference after graph alignment (Eq. 3), clipped to [0, 1]. Which evaluator axis each directive answers to was set by hand from the task rubric and confirmed by single-coordinate perturbations. The coefficients of D_i were then chosen by search on 60 validation tasks per family, and the anchors by a 0.01 grid search on the same tasks. No test task was used for calibration.

3. Confidence intervals for Table 3.

For 77.5 versus 77.4, the paired difference is +0.1 (95% CI [−1.117, 1.275], Holm p = 1.00), and the revision describes it as parity with budget-matched TextGrad. Coordination against HiveMind (75.7 vs 74.8) is also parity, with +0.9 (95% CI [−0.001, 1.795], Holm p = 0.42).

Questions

Q1. Backbone, test sets, task counts, score definitions and paired intervals.

Tables 1 to 4 use Qwen3-235B-A22B with three seeds. Table 1 uses the test sets below. Tables 2 to 4 use the same 160 MAB-Coding tasks with a lenient score that omits the budget term, so their absolute scores are 2.4 to 4.9 points above Table 1.

BenchmarkTest tasksScore definition
MAB-Coding / Research / Database160 / 134 / 116Official MultiAgentBench task score (TS) and coordination score (CS), 0 to 100
MATH500Accuracy of the normalized final answer
BigCodeBench500Pass@1, graded by the benchmark tests at final scoring only
AgentWebBench190Equal-weight mean of four normalized task-family scores

E.1 gives the hash-based rule that fixes each evaluation subset and its 60 validation IDs before any method is run. The evaluator's six input fields contain no reference answers or tests. Paired intervals against the strongest baseline in every column are in our response to Reviewer K8pa and in E.5. After Holm correction only AgentWebBench is significant (+5.7, 95% CI [3.910, 7.500], Holm p < 0.002), and the revised text claims parity elsewhere.

Q2. Scope of the stability guarantee.

Your reading is correct. The guarantee covers bounded commands and integral states (Prop. C.6), tracking of the reference filter (Lemma C.7) and conditional stability of a scalar local surrogate (Thm. C.5). It does not cover the implemented nonlinear system, and Sections 3.4 and 5 are narrowed accordingly. The selected non-root gains fail the scalar condition at the 90th-percentile sensitivity but satisfy it at the median sensitivity of all four actuator groups (L < 1.457 required, medians 0.87 to 1.21, spectral radius 0.84 to 0.89). Root agents satisfy it even at the 90th percentile. Beyond the analysis, C.11 adds an empirical test on logged runs. The tracking mismatch falls by 39% from round 1 to round 6 and no update saturates.

Thank you again for your review. We would be grateful to know whether our response and the revised PDF address your concerns, and we are happy to clarify anything further before the discussion period ends.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Revisions

We thank all three reviewers. Changed text in the revised PDF is marked in blue, and the main text stays within the 9-page limit. Table numbers in our responses refer to the revised PDF. The hyperparameter table is now Table 8 and the sensitivity table is Table 9. We removed the representative controller trajectory table from the main text and the separate five-agent cost configuration from the appendix.

Main text. The abstract and Section 4.2 now claim parity with the strongest adaptive baseline on most benchmarks and a significant advantage on AgentWebBench (+5.7 points, 95% CI [3.91, 7.50], Holm p < 0.002) (all reviewers). Section 3.2 states the reference generator used in all experiments (juVR, K8pa). Sections 3.4 and 5 limit the stability claim to what Appendix C proves (K8pa, juVR, Fqec). Every result table caption states its evaluation family, backbone, number of tasks and seeds (juVR, K8pa). Section 4.6 reports the robustness outcomes, and Section 5 names manual interface design and evaluator quality as the main limitations (Fqec, K8pa).

Appendix. E.1 gives the evaluation family, task counts, seeds and score definition for every result table. E.2 gives the evaluator model, decoding settings, prompts and inputs. E.3 gives the reference rule, directive templates, prompt composition and the interface design procedure with person-hours. E.4 reports online cost per task for every method. E.5 reports paired bootstrap intervals with Holm correction and the AgentWebBench task-family breakdown. E.6 reports Table 1 for all three backbones. C.3 and C.6 explain the unit eigenvalue and the scalar condition at median sensitivity, C.11 adds an empirical tracking test and C.12 reports directive response signs. Appendix G reports the feedback access ablations (Table 10) and all seven robustness conditions (Table 11). Table 8 now includes the AgentWebBench interface and the reference steps.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.