{"id":"d5fec91c-607d-4835-b5b4-10c862ade041","arxiv_id":"2501.11979","paper_version":1,"verdict":"REJECT","confidence":"HIGH","novelty_score":3.0,"correctness_risk":"high","formal_verification":"none","parameter_count":3,"one_line_summary":"A conceptual framework that maps iterative prompt refinement onto PID feedback control, without empirical validation.","lead":"This paper proposes treating iterative LLM prompt refinement as a feedback control problem, with a PID controller updating the prompt based on the difference between the model output and a target. It offers no experiments or implementation, only equations describing the analogy, so the practical value is not demonstrated.","discovery_kind":"incremental","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The load-bearing assumption is Eq. (2): p(t+1)=p(t)+u(t) must be a well-defined operation on prompts, but adding a real-valued control vector to a discrete token sequence (and to token/position indices in Eqs. 8-9) is undefined, so the claimed convergent loop has no well-defined update rule.","rationale":"The reader's weakest assumption correctly identifies the most load-bearing flaw: Eq. (2) claims an update p(t+1)=p(t)+u(t) where p(t) is a text prompt and u(t) is a real-valued control signal. Since prompts are discrete token sequences, this addition is undefined. The paper's own Section VI-B example reinforces the problem: it does not compute p(1) by vector addition; it paraphrases u(0) as textual instructions, which is a qualitatively different heuristic and not the mathematical loop described by Eqs. (2)-(13). Similarly, Eqs. (8) and (9) add u(t) to token IDs and positional indices in a way incompatible with standard tokenization and positional encodings. Even if one granted a continuous embedding-space interpretation, the paper gives no argument that the non-linear, stochastic LLM map, with noise terms in Eqs. (5)-(7), satisfies any condition that would make the PID loop converge; the assertion 'ensuring that the output y(t) converges towards the desired setpoint r(t)' in Section III-A is unsupported. There is also no empirical validation: the FPGA use case assumes y(1) 'might be' a favorable vector, and Section I explicitly defers implementation and evaluation to a follow-up publication. These are internal definitional and evidentiary gaps, not disagreements with external consensus. Because the reader already rejected the paper for essentially this reason, my stress-test pass does not change the verdict. A single concrete test would decide the matter: attempt to instantiate the update rule as written. If the addition cannot be performed on token sequences, the central claim is not a well-defined proposition about LLMs.","tokens_in":8486,"tokens_out":3670,"duration_ms":44566,"concrete_test":"Implement Eqs. (2), (8), and (9) literally on a small open-weight LLM with exposed tokenization and embeddings: set p(t) to integer token IDs, compute u(t) via Eq. (1) from a scalar output error, and construct p(t+1) by adding u(t) to each token ID and each positional index. If the resulting values are not valid token/position indices, the update rule has no implementation. If, instead, the author falls back to the natural-language instruction trick from Section VI-B, that is a different algorithm, and its convergence should be tested by running at least 20 FPGA-synthesis iterations and recording whether resource utilization monotonically approaches the 60% setpoint without hand-assumed intermediate values.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's central claim is that the PID update p(t+1)=p(t)+u(t) (Eq. 2) refines a prompt and drives the LLM output y(t) toward setpoint r(t). For this claim to hold, p(t)+u(t) must be a legitimate prompt for the LLM. But p(t) is a discrete token sequence, while u(t) is a real vector of resource-utilization errors and time units; no addition operation between these is defined. Section IV-A, Eq. (8), writes Embed(pi + u(t)), treating a token as if it could be shifted by a real vector; Eq. (9) writes PE(i + u(t)), adding a real number to a discrete positional index. Neither operation is meaningful in a transformer's tokenizer or positional-encoding lookup. The only concrete demonstration, Section VI-B, does not actually perform p(0)+u(0); it replaces the sum with a natural-language instruction such as 'Reduce resource usage by 6% LUTs, ...', which is a different algorithm from Eq. (2). Moreover, convergence is asserted without proof: no Lipschitz or contraction condition on f, g, phi, no bound on noise terms eta and nu, and no relation between Kp, Ki, Kd and the LLM dynamics is given to ensure e(t)->0. The paper itself states in Section I that 'the follow-up publication will detail the practical implementation and evaluation and release the source code,' conceding that the proposed mechanism has not been implemented or validated. Thus the loop's update rule is undefined in the mathematical sense that matters, and the claimed convergence has no well-defined object to apply to.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The manuscript proposes applying linear feedback control, specifically PID control, to iterative prompt optimization for LLMs. It defines a control signal u(t) from the error between the desired output r(t) and the measured LLM output y(t), and then updates the prompt by p(t+1)=p(t)+u(t). The paper introduces stochastic and nonlinear terms into the LLM output equations, describes how u(t) is injected into token embeddings, positional encodings, attention, and feed-forward layers, compares PID with Lead-Lag, LQR, and Fuzzy controllers, and gives an FPGA resource-utilization example to illustrate the proposed loop. The paper claims that this feedback loop ensures convergence of the LLM output to the setpoint and that it provides a theoretically grounded method for prompt optimization, while stating that practical implementation and evaluation are deferred to a follow-up publication.","tokens_in":8964,"tokens_out":1878,"duration_ms":21547,"significance":"If the central mechanism were well defined and the convergence claim were proven or empirically demonstrated, the analogy between PID control and prompt optimization could be a useful conceptual contribution. The paper does provide a clean presentation of control-theoretic notation and a plausible high-level analogy, but it contains no implementation, no experiments, and no machine-checked or formal verification of its claims. The contribution is therefore currently only an analogy accompanied by equations; its practical and scientific value depends entirely on the undefined update rule and unsupported convergence assertion, which the manuscript does not resolve.","major_comments":[{"comment":"The update rule p(t+1)=p(t)+u(t) is not a well-defined operation: p(t) is a discrete token sequence while u(t) is a real-valued control vector computed from resource-utilization percentages and timing units. The paper never defines what it means to add a real vector to a token sequence, and the only concrete demonstration in Section VI-B replaces this addition with a natural-language instruction such as 'Reduce resource usage by 6% LUTs, 3% FFs...', which is a different algorithm from the equation. Since Eq. (2) is the core mechanism of the claimed loop, this is a load-bearing gap.","section":"Section III-A, Eq. (2)"},{"comment":"The injection of u(t) into embeddings and positional encodings is also undefined: Eq. (8) writes Embed(pi + u(t)) and Eq. (9) writes PE(i + u(t)), where pi is a token and i is an integer positional index, but no addition operation between a token or an integer and a real vector is specified in the tokenizer or positional-encoding lookup. The subsequent equations (10)-(13) inherit this undefinedness because they all depend on u(t) as an additive quantity to inputs, keys, queries, and values.","section":"Section IV-A and IV-B, Eqs. (8) and (9)"},{"comment":"The claim that 'the output y(t) converges towards the desired setpoint r(t)' is asserted without proof or sufficient assumptions. The manuscript introduces stochastic noise eta(t) and nu(t) and a nonlinear transformation g, but it provides no Lipschitz, contraction, monotonicity, or bounded-noise conditions on f, g, phi, or eta/nu, and no relation between the PID gains Kp, Ki, Kd and the LLM dynamics that would imply e(t) -> 0. The equations in Section III-B are descriptive definitions, not a stability analysis.","section":"Section III-A and Eqs. (5)-(7)"},{"comment":"The presented example does not demonstrate convergence; it assumes it. The value y(1) is stipulated as 'might be' a certain vector, and then e(1) and u(1) are computed from that stipulated value, so the error reduction is injected by the author rather than produced by the update rule. In addition, the integral term is evaluated as zero at t=0 with no justification, and the derivative term de(0)/dt is not computable from the data given, so the numerical values of u(0) and u(1) are not derived from the stated PID law.","section":"Section VI-B, Example computation"},{"comment":"The paper itself states that 'the follow-up publication will detail the practical implementation and evaluation of this theory... and release the source code', which is an explicit acknowledgment that the proposed mechanism has not been implemented or validated. For a paper whose central claims are about a working feedback loop that 'ensures' convergence, the absence of any experimental or simulated evaluation leaves those claims unsubstantiated within the manuscript's scope.","section":"Section I and Conclusion"}],"minor_comments":[{"comment":"The notation 'equ (1)', 'equ (2)', and similar appears repeatedly; the manuscript should use consistent equation references such as 'Eq. (1)'.","section":"Throughout"},{"comment":"In Eq. (7), the noise term is written as nu(t) while the output is y(t+1); the time index of the noise term should be clarified to be consistent with the stochastic process description.","section":"Eq. (7)"},{"comment":"The distinction between sigma(t) and y(t) and the roles of beta and phi are introduced informally; a single table or list defining all variables would improve readability.","section":"Section III-B"},{"comment":"The comparison of PID with Lead-Lag, LQR, and Fuzzy controllers is qualitative only; the paper should at least state that no simulation or benchmark is used for this comparison, since the text suggests relative effectiveness without evidence.","section":"Section V"}],"recommendation":"reject","confidential_remarks":"This manuscript is best characterized as a position or idea paper: it draws an analogy between PID control and prompt optimization, but the central update rule is not mathematically well defined, the convergence claim is not proven, and the paper explicitly defers implementation and evaluation to a future publication. The reported example is a hand-constructed illustration that assumes the improved LLM output rather than producing it. These issues are load-bearing for the paper's main claim and cannot be fixed by local revision; the manuscript would need a fundamentally reformulated mechanism and an actual evaluation before it could meet the standards of a research contribution. The scope and presentation are also more typical of a workshop position statement than a full archival paper."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague,\n\nShort version: this paper is not a research result. It takes the textbook PID control law, relabels the LLM as the plant, and asserts that updating a prompt by a real-valued vector u(t) drives the output to a setpoint. The update rule p(t+1)=p(t)+u(t) (Eq. 2) is undefined for discrete token sequences, and the one worked example avoids the problem by replacing the vector sum with an English sentence like \"Reduce resource usage by 6% LUTs...\" That is a different algorithm from the equation, and it means the claimed convergent loop has no well-defined update rule.\n\nWhat the paper does well is the framing. The analogy between iterative prompt refinement and feedback control is a legitimate pedagogical perspective, and the author is candid that this is early-stage: the introduction says implementation and evaluation are deferred to a follow-up. The paper also flags the obvious challenges of LLM stochasticity and nonlinearity and cites relevant work.\n\nThe soft spots are load-bearing, not cosmetic. There is no convergence proof: no Lipschitz or contraction condition on f, g, or phi, no bound on the noise terms eta and nu, and no analysis of how the PID gains interact with the LLM's dynamics. Sections IV just inserts u(t) into the standard transformer forward pass (Eqs. 8-13), which adds notation but no content. The comparison with other controllers is qualitative and doesn't demonstrate any advantage. The claimed continuity from control theory to LLMs rests entirely on an operation that is never defined.\n\nI agree with the reader's take. This reads like a proposal sketch rather than a paper with a mathematical foundation. A serious editor would desk reject it. That said, the underlying idea could be made concrete: if the author actually implemented a controller that operates on embeddings or on text-based corrections and measured convergence on real tasks, then there might be a valid contribution. What's here does not justify referee time.\n\nRecommendation: reject, don't send to review.","headline":"A framing analogy with no working mechanism: the central update rule p(t+1)=p(t)+u(t) is undefined for text prompts, and the paper's own example substitutes a natural-language instruction for the vector addition.","tokens_in":9421,"tokens_out":2074,"would_cite":false,"duration_ms":21956,"reading_group":"no","serious_thinker":"no","would_accept_peer_review":false},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper claims that iterative prompt optimization can be cast as a feedback loop in which a PID controller computes each prompt update from the output error.","keywords":["prompt optimization","feedback control","PID controller","large language models","iterative refinement","control theory","setpoint tracking","transformer attention"],"falsifier":"Run the paper's FPGA example exactly: starting from the initial prompt, translate each computed $u(t)$ into a textual instruction, synthesize the resulting HLS C code, and measure LUT/FF/DSP/BRAM utilization; if the resource-utilization error $r(t)-y(t)$ does not shrink toward zero or grows over successive iterations, the convergence claim is false for that setting.","tokens_in":8323,"feed_emoji":"🎛️","tokens_out":7188,"duration_ms":72357,"temperature":0.7,"pith_summary":"Prompt optimization today is largely guesswork and rephrasing. The paper's proposal is to treat it as a feedback control problem: measure the difference between the model's output and a desired setpoint, run that error through a PID controller, and add the controller's output to the prompt at each step. It claims that this closed loop drives the LLM's output toward the target even though the LLM is nonlinear and stochastic, because the error term is what shapes each prompt update. If the framework holds, prompt engineering would gain a systematic mathematical update rule instead of trial and error, and decades of controller-tuning knowledge could be imported into working with language models. The paper itself presents the mathematical setup and a hand-worked FPGA example, and states that practical implementation and evaluation will appear in a follow-up publication.","feed_headline":"PID-style feedback loop drives prompt updates toward a target output","feed_subtitle":"A control-theory framing tells you exactly how to change the prompt from one iteration to the next.","key_machinery":"The load-bearing object is the PID control law and its insertion point. The controller computes $u(t)$ from the error between setpoint and measured output; the paper then applies this same $u(t)$ in Eq. (2) to update the prompt and in Eqs. (8)--(13) to perturb token embeddings, positional indices, and attention matrices. This imported proportional/integral/derivative decomposition is what carries the argument: proportional action reacts to the current output gap, integral action accumulates past gaps (which the paper argues gives session memory in stateful chatbots), and derivative action smooths against abrupt prompt changes. Without this insertion mechanism there is no closed loop.","core_discovery":"The central claim is that the update rule $p(t+1)=p(t)+u(t)$, with $u(t)$ given by the PID law $u(t)=K_pe(t)+K_i\\int_0^t e(\\tau)d\\tau + K_d\\frac{de(t)}{dt}$ and $e(t)=r(t)-\\hat y(t)$, turns an LLM into a controllable system. The paper models the LLM output as $\\sigma(t+1)=g(f(p(t+1))) + \\eta(t)$ and the system output as $y(t+1)=\\phi(\\sigma(t+1)) + \\nu(t)$, then inserts $u(t)$ into tokenization, embeddings, positional encodings, attention queries/keys/values, and the output projection. It asserts that these insertions make the prompt the manipulated variable of a closed loop and that repeated application of the update makes $y(t)$ converge to the setpoint $r(t)$, with a worked FPGA resource-utilization example showing error reductions across iterations.","pith_inferences":["A direct test not run in the paper would fix a benchmark task, define a semantic or heuristic output metric as the setpoint, and record whether PID-updated prompts decrease that metric's error over successive iterations.","Because the paper writes the update as addition but demonstrates it as a textual instruction, translating $u(t)$ into natural-language directives is itself an underspecified design choice; an embedding-space implementation that decodes a shifted prompt vector would test the equation more literally.","The framework suggests a plant-identification step: measuring an LLM's local input--output sensitivity around a prompt would provide empirical bounds on $K_p$ and show where the linear-control assumption starts to fail."],"forward_implications":["If convergence holds, classic controller-tuning recipes such as Ziegler-Nichols can be imported to set $K_p$, $K_i$, $K_d$ for prompt-refinement loops.","In stateless API settings the paper's model predicts the integral and derivative terms are effectively zero, so prompt quality should be governed mainly by the proportional term $K_pe(t)$.","The same loop should apply to any measurable output criterion, since the system block $\\phi$ only needs to map the LLM output to a scalar or vector setpoint error.","Comparing PID with lead-lag, LQR, and fuzzy controllers on the same prompt-optimization task becomes a meaningful experiment within this framework, since each controller defines a different $u(t)$ update law."],"supporting_citations":[{"why":"Supplies the PID control law that the paper uses to compute prompt updates.","marker":"[8]"},{"why":"Supplies PID tuning-method context (Ziegler-Nichols, Cohen-Coon) that the framework imports for setting gains.","marker":"[10]"},{"why":"Provides the Ziegler-Nichols tuning method cited as the way to choose $K_p$, $K_i$, $K_d$.","marker":"[12]"},{"why":"Supplies the transformer attention and positional-encoding machinery into which the control signal is inserted.","marker":"[19]"},{"why":"Identifies the specific LLM used as the plant in the loop.","marker":"[13]"},{"why":"Provides the feedback-systems background that motivates treating output deviation as a closed-loop error.","marker":"[5]"}],"fun_headline_variants":["PID feedback loop drives LLM prompts to hit the target","Control theory gives LLMs a PID prompt-update rule","Prompt optimization via linear feedback control systems","LLM prompt tuning gets a PID controller for convergence","Closed-loop prompt updates using PID error correction"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The whole method depends on being able to add a number to a prompt, to token positions, and to embeddings, but a prompt is a sequence of words and that addition has no defined meaning.","fun_headline_variants_meta":{"raw":{"variants":["PID feedback loop drives LLM prompts to hit the target","Control theory gives LLMs a PID prompt-update rule","Prompt optimization via linear feedback control systems","LLM prompt tuning gets a PID controller for convergence","Closed-loop prompt updates using PID error correction"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000269,"raw_usage":{"total_tokens":1580,"prompt_tokens":865,"completion_tokens":715,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":481,"completion_tokens_details":{"reasoning_tokens":642}},"tokens_in":481,"tokens_out":715,"duration_ms":8309,"temperature":1.0,"reasoning_tokens":642,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T17:38:01.535762+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the paper's FPGA example exactly: starting from the initial prompt, translate each computed $u(t)$ into a textual instruction, synthesize the resulting HLS C code, and measure LUT/FF/DSP/BRAM utilization; if the resource-utilization error $r(t)-y(t)$ does not shrink toward zero or grows over successive iterations, the convergence claim is false for that setting.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies the PID control law that the paper uses to compute prompt updates."},{"cited_title":"A review of pid control, tuning methods and applications,","cited_arxiv_id":null,"evidence_quote":"Supplies PID tuning-method context (Ziegler-Nichols, Cohen-Coon) that the framework imports for setting gains."},{"cited_title":"Ziegler-nichols tuning method: Understanding the pid controller,","cited_arxiv_id":null,"evidence_quote":"Provides the Ziegler-Nichols tuning method cited as the way to choose $K_p$, $K_i$, $K_d$."},{"cited_title":"Chatgpt and open-ai models: A preliminary review,","cited_arxiv_id":null,"evidence_quote":"Identifies the specific LLM used as the plant in the loop."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Provides the feedback-systems background that motivates treating output deviation as a closed-loop error."}],"review_version":1}