LLM-generated drafts often contain subtle factual or logical errors, yet prior work shows that models struggle to reliably integrate multi-turn feedback aimed at fixing them. We propose in-place feedback, an interaction paradigm in which the user directly edits the model's previous response and the model continues generation from the edited context. In-place feedback consistently outperforms standard multi-turn feedback across five reasoning-intensive benchmarks while requiring fewer tokens, and our fine-grained analysis shows that it applies corrections more reliably and propagates them to subsequent reasoning. A user study with domain experts refining LLM-generated summaries corroborates these findings: participants report higher final-output satisfaction and substantially lower fatigue with in-place feedback, and a mixed strategy combining in-place and multi-turn feedback improves every dimension we measure. These results suggest that editing errors in place is a more reliable way to incorporate expert corrections than multi-turn feedback, while combining the two acts complementarily to form a more effective collaboration than either mechanism alone.
Figures & tables
Figure 1: Illustration of common failure cases in multi-turn conversational feedback and in-place feedback. After in-place feedback, the LLM continues generation from the green word “ requires ”.
Figure 2: Representative examples of in-place feedback on a toy problem. Red marks incorrect reasoning in the original response, blue indicates user corrections with in-place feedback, and green shows the subsequent reasoning based on the corrected context. Additional examples are provided in Section I.1 .
Figure 3: Performance comparison across five datasets. Across all datasets and LLMs, in-place feedback consistently outperforms the multi-turn and memory-based feedback approaches. The points with black borders represent the baselines’ performance at the last turn.
Figure 4: The number of input and generated tokens across multiple turns for Gemma-3-4b-it . In-place feedback consistently requires fewer tokens than multi-turn feedback. The token counts for the other models and datasets can be found in Appendix H .
Dataset
Model
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
MATH-hard
Qwen
Multi-turn
0.550
0.684
0.738
0.766
0.792
0.816
0.838
0.850
0.858
0.862
Localized MT
0.550
0.682
0.758
0.790
0.808
0.830
0.838
0.848
0.852
0.858
In-place
0.550
0.714
0.766
0.812
0.852
0.888
0.904
0.918
0.924
0.928
Gemma
Multi-turn
0.492
0.606
0.684
0.730
0.760
0.776
0.792
0.804
0.820
0.828
Localized MT
0.492
0.612
0.692
0.750
0.776
0.794
0.808
0.824
0.838
0.846
Table 1: Cumulative accuracy on MATH-hard and GPQA with Qwen-2.5-7B-Instruct and Gemma-3-4B-it . Localized MT uses the same in-place agent as in-place feedback, but the edited response is delivered as a multi-turn user message with the full dialogue history.
Figure 5: CPR, FAR, and CTRR for 10-turn. The points with a black border represent the second response of the LLMs (i.e., y1 ), and the subsequent responses across turns are connected by lines.
Figure 6: Impact of accumulated dialogue history. For CPR, FAR, and CTRR, we report the difference between the multi-turn feedback rates and the rates under pruned-history settings. Negative values indicate performance degradation due to accumulated history.
Method
Strengths
Weaknesses
Multi-turn
“Generates natural sentences that reflect my intended nuance when I know the direction but not the exact wording.”, “Good at revising the overall flow.”
“Fatigue becomes severe when the model repeats the same mistake after correction.”, “Untargeted parts get modified, and previously accepted edits are undone.”, “Waiting for full regeneration every turn is tiring.”
In-place
“I can quickly convey my intent without making the model understand it first.”, “Convenient for fixing a word or phrase directly.”, “Useful when the opening of a sentence is fixed and I want the model to continue naturally.”
“The model’s drafting ability is hard to leverage when I don’t know how to fix it myself.”, “Sentences after the edited region sometimes change slightly.”, “Tedious when many small items need to be removed at once.”
Mixed
“Restructuring with multi-turn first and then polishing details with in-place was the most efficient.”, “Combines the advantages of both methods.”, “Lowest fatigue and highest satisfaction overall.”
“Choosing which mode to use for each edit is itself a small burden.”, “I tended to use in-place as the default and multi-turn only as a fallback.”
Table 2: Summary of user experience across interaction modes. Representative strengths and weaknesses of three interaction modes from open-ended responses collected in our user study.
Figure 7: User study results across the five questionnaire items, scored on a 1–10 scale (higher is better; for fatigue , 10 corresponds to not fatigued ). In-place feedback outperforms standard multi-turn feedback on every dimension, and a mixed strategy that combines both paradigms is rated highest overall.
Appendix figures & tables73 assets
Supplementary material from the paper’s appendix.
Appendix
Figure D.1: Grid and cell accuracy on the ZebraLogic dataset. Top- 4 feedback is used.
Figure D.2: Grid and cell accuracy on the ZebraLogic dataset. Top- 2 feedback is used.
Figure D.3: CPR, FAR, and CTRR for 10-turn with top-2 feedback. Filled points denote in-place feedback, and hollow points denote multi-turn feedback. The points with a black border represent the second response of the LLMs (i.e., y1 ), and the subsequent responses across turns are connected by lines.
Figure D.4: CPR, FAR, and CTRR for 10-turn conversations of LLMs on the ZebraLogic dataset. Top- 4 feedback is used. The points with a black border represent the second response of the LLMs (i.e., y1 ), and the subsequent responses across turns are connected by lines.
Figure D.5: CPR, FAR, and CTRR for 10-turn conversations of LLMs on the ZebraLogic dataset. Top- 2 feedback is used. The points with a black border represent the second response of the LLMs (i.e., y1 ), and the subsequent responses across turns are connected by lines.
Figure D.6: Grid and cell accuracy of LLMs on the ZebraLogic dataset. In-place feedback consistently outperforms multi-turn feedback under an oracle setting.
Figure D.7: CPR, FAR, and CTRR for 10-turn conversations of LLMs on the ZebraLogic dataset. The oracle feedback function is used. Filled points denote in-place feedback, and hollow points denote multi-turn feedback. The points with a black border represent the second response of the LLMs (i.e., y1 ), and the subsequent responses across turns are connected by lines.
Model
Method
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
0.005
0.009
0.010
0.014
0.016
0.017
0.017
0.019
0.021
0.024
In-place
0.005
0.009
0.017
0.028
0.037
0.049
0.059
0.068
0.079
0.086
Gemma
Multi-turn
0.000
0.002
0.003
0.005
0.009
0.010
0.017
0.019
0.021
0.023
In-place
0.000
0.009
0.018
0.034
0.042
0.044
0.055
0.067
0.076
0.090
Appendix
Table E.1: Grid accuracy on ZebraLogic under incomplete top-4 feedback. Feedback indicates only that a cell is incorrect, without providing the correct value.
Model
Method
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
0.274
0.284
0.290
0.296
0.295
0.297
0.296
0.299
0.300
0.299
In-place
0.274
0.304
0.341
0.372
0.395
0.414
0.434
0.444
0.453
0.449
Gemma
Multi-turn
0.273
0.283
0.307
0.319
0.333
0.344
0.346
0.346
0.354
0.361
In-place
0.273
0.309
0.336
0.371
0.392
0.414
0.424
0.449
0.461
0.472
Appendix
Table E.2: Cell accuracy on ZebraLogic under incomplete top-4 feedback.
Model
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
0.550
0.596
0.614
0.622
0.624
0.626
0.632
0.634
0.634
0.634
In-place
0.550
0.606
0.632
0.646
0.650
0.660
0.666
0.668
0.676
0.686
Gemma
Multi-turn
0.492
0.566
0.610
0.630
0.646
0.650
0.658
0.664
0.670
0.670
In-place
0.492
0.600
0.638
0.658
0.684
0.694
0.698
0.710
0.714
0.722
Appendix
Table E.3: Incomplete-feedback ablation on MATH-hard. Feedback only identifies the erroneous part of the previous response, without specifying how to correct it.
Model
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
0.103
0.119
0.119
0.143
0.143
0.151
0.151
0.151
0.159
0.159
In-place
0.103
0.119
0.119
0.151
0.191
0.198
0.214
0.230
0.230
0.230
Gemma
Multi-turn
0.056
0.079
0.079
0.087
0.103
0.103
0.103
0.103
0.111
0.111
In-place
0.056
0.087
0.087
0.111
0.127
0.127
0.135
0.143
0.143
0.151
Appendix
Table E.4: Incomplete-feedback ablation on GPQA. Feedback only identifies the erroneous part of the previous response, without specifying how to correct it.
Valid reasoning discarded beyond what feedback necessitated.
Under-prune
3.8
39.9
Erroneous downstream content retained.
Partial address
33.4
–
Feedback partially incorporated.
Misapplied
2.4
4.2
Feedback misunderstood or not reflected in the edit.
Excessive
–
1.6
1.3
Rewriting valid content beyond feedback scope.
Appendix
Table E.5: Reliability analysis of the in-place agent on MATH-Hard (Gemma-3-4b-it) and ZebraLogic (top-4 feedback), evaluated by Claude 4.5 Sonnet as LLM-judge. Most edits are appropriate or incomplete; aggressive over-rewriting (excessive) is rare.
Figure G.1: Performance comparison in MATH-hard, MMLU-pro, GPQA, and LiveCodeBench. Across all datasets and large-scale LLM models, in-place feedback consistently outperforms the multi-turn and memory-based feedback approaches. Tabulated results are provided in Tables G.1 , G.2 , G.3 and G.4 .
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
31.2
52.6
63.2
71.0
74.6
Memory
31.2
51.6
62.2
67.0
72.4
In-place
31.2
53.6
64.6
71.8
76.8
Gemma-3-27B
Multi-turn
78.2
86.6
89.2
90.4
91.0
Memory
78.2
86.2
87.8
89.8
90.8
Appendix
Table G.1: Performance comparison on MATH-hard.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
54.8
70.2
75.3
77.1
77.9
Memory
54.8
68.8
76.5
78.5
80.2
In-place
54.8
70.6
77.7
79.1
81.3
Gemma-3-27B
Multi-turn
61.3
73.4
76.3
79.3
80.5
Memory
61.3
74.6
78.7
80.3
81.4
Appendix
Table G.2: Performance comparison MMLU-pro.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
18.3
29.4
42.1
46.0
50.8
Memory
18.3
30.2
40.5
46.6
50.8
In-place
18.3
31.8
42.9
46.8
53.2
Gemma-3-27B
Multi-turn
17.5
34.1
42.9
48.4
51.6
Memory
17.5
33.3
39.7
44.4
47.6
Appendix
Table G.3: Performance comparison on GPQA.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
49.1
62.3
68.9
73.1
76.1
Memory
49.1
56.9
63.5
66.5
70.1
In-place
49.1
65.3
71.9
74.3
77.3
Gemma-3-27B
Multi-turn
54.5
76.1
80.8
84.4
85.6
Memory
54.5
76.1
80.8
84.4
86.8
Appendix
Table G.4: Performance comparison on LiveCodeBench.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
231.0
715.1
1373.4
2070.4
2902.1
Memory
231.0
740.4
1059.7
1301.0
1340.6
In-place
231.0
378.0
472.7
534.1
610.2
Gemma-3-27B
Multi-turn
177.9
1833.3
3527.8
4934.1
6250.7
Memory
177.9
1897.3
1769.4
1958.0
2020.5
Appendix
Table G.5: Number of input tokens on Math-hard.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
165.1
747.6
1342.3
1987.7
2608.3
Memory
165.1
776.8
954.3
1187.8
1210.4
In-place
165.1
451.9
515.8
560.3
595.4
Gemma-3-27B
Multi-turn
149.0
894.6
1672.0
2454.1
3209.8
Memory
149.0
924.6
1117.7
1315.8
1314.0
Appendix
Table G.6: Number of input tokens on MMLU-pro.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
224.1
998.2
1720.3
2405.4
3099.9
Memory
224.1
1027.5
1138.1
1309.9
1307.2
In-place
224.1
585.9
636.0
694.4
752.2
Gemma-3-27B
Multi-turn
205.0
1085.9
1903.6
2754.2
3606.0
Memory
205.0
1115.9
1230.8
1380.2
1414.2
Appendix
Table G.7: Number of input tokens on GPQA.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
584.3
1317.0
2055.4
2835.1
3598.0
Memory
584.3
1342.2
1439.8
1648.5
1662.7
In-place
584.3
931.8
1007.7
1080.3
1186.6
Gemma-3-27B
Multi-turn
594.3
1251.5
1922.7
2529.5
3266.9
Memory
594.3
1571.1
1914.6
2182.0
2254.8
Appendix
Table G.8: Number of input tokens on LiveCodeBench.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
915.3
2488.4
4109.8
5844.1
7626.1
Memory
915.3
2454.8
2250.5
2460.7
2558.0
In-place
915.3
2147.0
3037.9
3612.3
4322.2
Gemma-3-27B
Multi-turn
961.4
2269.8
2971.6
3663.9
4401.4
Memory
961.4
2245.8
2133.8
2421.5
2599.9
Appendix
Table G.9: Number of input tokens on ZebraLogic.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
279.8
380.0
482.5
522.4
593.4
Memory
279.8
434.3
555.5
615.1
592.4
In-place
279.8
249.2
239.0
315.2
300.5
Gemma-3-27B
Multi-turn
927.4
1134.5
1238.2
1154.2
1098.9
Memory
927.4
969.4
1134.5
1222.9
1204.4
Appendix
Table G.10: Number of generated tokens on Math-hard.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
310.1
385.4
423.6
467.4
477.6
Memory
310.1
432.1
515.1
575.7
623.8
In-place
310.1
153.9
160.8
166.7
147.7
Gemma-3-27B
Multi-turn
420.3
511.5
561.6
561.3
605.3
Memory
420.3
586.8
680.9
712.1
723.7
Appendix
Table G.11: Number of generated tokens on MMLU-pro.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
597.8
549.2
508.2
515.6
571.9
Memory
597.8
574.9
607.8
600.5
620.3
In-place
597.8
280.1
229.7
232.3
259.7
Gemma-3-27B
Multi-turn
738.9
641.1
643.1
666.4
679.0
Memory
738.9
683.3
728.2
751.3
749.8
Appendix
Table G.12: Number of generated tokens on GPQA.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
467.9
488.3
513.9
553.0
517.2
Memory
467.9
369.2
392.5
420.2
429.3
In-place
467.9
233.2
217.7
238.8
212.5
Gemma-3-27B
Multi-turn
449.1
573.4
499.5
472.8
522.9
Memory
449.1
552.9
704.2
835.5
895.1
Appendix
Table G.13: Number of generated tokens on LiveCodeBench.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
1429.6
1444.6
1439.1
1431.2
1445.6
Memory
1429.6
1126.5
1200.4
1178.2
1216.5
In-place
1429.6
1069.6
791.1
762.5
666.8
Gemma-3-27B
Multi-turn
1191.3
575.1
590.1
585.2
605.5
Memory
1191.3
985.0
1153.2
1250.3
1313.4
Appendix
Table G.14: Number of generated tokens on ZebraLogic.
Figure G.2: Grid and cell accuracy on the ZebraLogic dataset with large-scale LLMs. Tabulated results are provided in Tables G.15 , G.17 , G.16 and G.18 .
Figure G.3: CPR, FAR, and CTRR for five-turn conversations of large-scale LLMs on the ZebraLogic dataset with top- 4 feedback. The points with a black border represent the second response of the LLMs (i.e., y1 ), and the subsequent responses across turns are connected by lines.
Figure G.4: CPR, FAR, and CTRR for five-turn conversations of large-scale LLMs on the ZebraLogic dataset with top- 2 feedback. The points with a black border represent the second response of the LLMs (i.e., y1 ), and the subsequent responses across turns are connected by lines.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
0.031
0.140
0.314
0.550
0.691
Memory
0.031
0.134
0.326
0.489
0.674
In-place
0.031
0.131
0.330
0.574
0.740
Gemma-3-27B
Multi-turn
0.042
0.103
0.204
0.330
0.482
Memory
0.042
0.122
0.241
0.384
0.518
Appendix
Table G.15: Grid accuracy of large-scale LLMs on ZebraLogic with top- 4 feedback.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
0.031
0.096
0.195
0.337
0.492
Memory
0.031
0.108
0.234
0.360
0.455
In-place
0.031
0.096
0.201
0.335
0.475
Gemma-3-27B
Multi-turn
0.042
0.094
0.166
0.234
0.314
Memory
0.042
0.099
0.180
0.262
0.344
Appendix
Table G.16: Grid accuracy of large-scale LLMs on ZebraLogic with top- 2 feedback.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
0.354
0.554
0.713
0.819
0.890
Memory
0.354
0.559
0.714
0.816
0.871
In-place
0.354
0.565
0.731
0.832
0.890
Gemma-3-27B
Multi-turn
0.392
0.564
0.698
0.800
0.875
Memory
0.392
0.567
0.684
0.774
0.834
Appendix
Table G.17: Cell accuracy of large-scale LLMs on ZebraLogic. Top- 4 feedback is used.
Model
Method
Number of turns
0
1
2
3
4
Llama-3.1-70B
Multi-turn
0.354
0.480
0.590
0.694
0.756
Memory
0.354
0.485
0.580
0.640
0.696
In-place
0.354
0.487
0.599
0.677
0.730
Gemma-3-27B
Multi-turn
0.392
0.499
0.586
0.651
0.711
Memory
0.392
0.496
0.578
0.645
0.699
Appendix
Table G.18: Cell accuracy of large-scale LLMs on ZebraLogic with top- 2 feedback.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
55.0
68.4
73.8
76.6
79.2
81.6
83.8
85.0
85.8
86.2
Memory
55.0
62.6
66.2
69.2
71.2
72.8
74.2
75.0
76.4
77.4
In-place
55.0
71.4
76.6
81.2
85.2
88.8
90.4
91.8
92.4
92.8
Gemma
Multi-turn
49.2
60.6
68.4
73.0
76.0
77.6
79.2
80.4
82.0
82.8
Memory
49.2
60.4
65.0
68.0
70.6
72.6
74.6
76.4
77.2
78.0
Appendix
Table H.1: Performance comparison on Math-hard.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
56.2
68.0
72.6
75.1
77.3
78.1
79.1
79.3
80.1
80.5
Memory
56.2
67.1
70.8
73.4
75.7
77.7
78.5
79.7
80.7
80.9
In-place
56.2
69.8
78.5
80.1
81.9
83.0
83.8
84.6
85.0
85.4
Gemma
Multi-turn
41.4
54.0
60.0
65.9
68.4
69.8
71.2
72.0
72.8
73.4
Memory
41.4
52.9
57.2
63.5
66.3
68.0
69.6
70.4
71.6
72.2
Appendix
Table H.2: Performance comparison on MMLU-pro.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
10.3
17.5
27.8
38.1
40.5
42.9
43.7
43.7
43.7
46.0
Memory
10.3
19.0
27.0
29.4
34.9
36.5
37.3
38.1
38.1
38.9
In-place
10.3
25.4
36.5
48.4
51.6
57.9
63.5
64.3
66.7
69.0
Gemma
Multi-turn
5.6
9.5
11.9
14.3
15.1
19.0
22.2
23.0
24.6
27.0
Memory
5.6
8.7
10.3
13.5
15.9
17.5
18.3
22.2
22.2
23.8
Appendix
Table H.3: Performance comparison on GPQA.
Model
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
0.033
0.033
0.067
0.067
0.067
0.067
0.100
0.100
0.100
0.100
Memory
0.033
0.033
0.067
0.100
0.100
0.100
0.100
0.100
0.100
0.100
In-place
0.033
0.200
0.233
0.300
0.333
0.433
0.433
0.467
0.467
0.467
Gemma
Multi-turn
0.100
0.133
0.133
0.167
0.167
0.167
0.167
0.167
0.167
0.167
Memory
0.100
0.100
0.200
0.233
0.267
0.300
0.300
0.333
0.333
0.333
Appendix
Table H.4: Cumulative accuracy on AIME 2025.
Model
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Qwen
Multi-turn
0.067
0.100
0.100
0.100
0.100
0.133
0.133
0.133
0.133
0.133
Memory
0.067
0.067
0.067
0.067
0.067
0.067
0.067
0.067
0.067
0.067
In-place
0.067
0.133
0.233
0.267
0.333
0.467
0.533
0.533
0.533
0.533
Gemma
Multi-turn
0.067
0.133
0.167
0.167
0.167
0.167
0.167
0.200
0.200
0.200
Memory
0.067
0.067
0.133
0.133
0.200
0.200
0.200
0.200
0.200
0.200
Appendix
Table H.5: Cumulative accuracy on AIME 2026.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Llama
Multi-turn
231.0
800.9
1572.4
2453.3
3513.4
4433.9
5513.2
6621.6
7854.8
8949.1
Memory
231.0
826.2
1073.4
1319.3
1361.2
1414.1
1413.2
1468.8
1515.9
1566.9
In-place
231.0
373.3
456.5
533.1
608.1
666.8
733.2
790.0
825.0
872.1
Gemma
Multi-turn
165.9
1822.6
3247.8
4640.9
5850.4
7188.1
8483.4
9833.5
11076.5
12444.9
Memory
165.9
1898.6
1537.5
1712.3
1717.8
1737.9
1712.2
1744.5
1739.2
1720.0
Appendix
Table H.6: Number of input tokens on Math-hard.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Llama
Multi-turn
165.1
800.4
1473.2
2164.4
2871.0
3594.4
4274.1
4962.2
5578.6
6248.8
Memory
165.1
829.6
973.4
1157.5
1209.8
1224.9
1256.0
1237.0
1249.4
1279.0
In-place
165.1
422.1
487.9
534.0
592.6
625.2
665.0
638.6
677.9
670.8
Gemma
Multi-turn
149.0
975.2
1770.5
2545.2
3392.5
4187.6
4961.9
5791.9
6656.0
7565.4
Memory
149.0
1005.2
1078.5
1191.2
1210.4
1217.3
1256.2
1272.8
1267.5
1285.5
Appendix
Table H.7: Number of input tokens on MMLU-pro.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Llama
Multi-turn
224.1
1054.1
1859.6
2744.6
3635.5
4503.7
5393.5
6302.9
7250.4
8134.1
Memory
224.1
1083.4
1181.7
1394.7
1389.8
1360.0
1377.9
1354.2
1319.9
1340.8
In-place
224.1
522.0
611.1
689.5
725.9
740.0
770.9
806.7
890.8
876.4
Gemma
Multi-turn
205.0
1197.2
2138.4
3073.1
3996.3
4913.9
5850.2
6865.6
7829.9
8823.9
Memory
205.0
1227.2
1322.4
1482.0
1466.4
1508.8
1522.3
1498.5
1524.4
1503.4
Appendix
Table H.8: Number of input tokens on GPQA.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Llama
Multi-turn
932.3
2748.8
4089.0
5760.6
7508.6
9251.7
11123.1
12914.4
14775.8
16653.6
Memory
932.3
2700.9
2275.6
2312.4
2370.3
2402.9
2433.7
2439.4
2434.0
2386.2
In-place
932.3
2166.4
2709.9
3171.8
3641.0
4069.7
4551.9
5079.0
5519.2
5878.4
Gemma
Multi-turn
1004.4
2249.6
3464.7
4709.9
5963.8
7295.7
8601.6
9843.2
11092.1
12269.7
Memory
1004.4
2171.6
2341.8
2414.9
2479.8
2470.6
2490.3
2520.4
2534.1
2525.8
Appendix
Table H.9: Number of input tokens on ZebraLogic.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Llama
Multi-turn
395.2
504.4
587.3
661.0
730.8
734.3
792.9
809.8
852.6
923.6
Memory
395.2
479.1
588.1
647.8
696.7
705.3
743.1
790.1
844.8
861.5
In-place
395.2
294.1
307.8
331.9
328.6
351.5
373.8
388.6
364.8
432.4
Gemma
Multi-turn
1138.3
1152.2
1098.2
1074.0
1070.4
1087.0
1063.4
1091.2
1081.9
1119.2
Memory
1138.3
907.0
961.6
986.1
987.7
984.3
999.7
1041.3
1013.6
992.2
Appendix
Table H.10: Number of generated tokens on Math-hard.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Llama
Multi-turn
381.4
432.4
477.4
480.0
499.4
537.3
537.0
514.7
518.2
546.3
Memory
381.4
429.7
515.0
574.6
603.1
627.7
617.2
650.2
662.3
642.3
In-place
381.4
236.2
236.7
206.9
214.0
212.8
188.0
249.9
223.5
253.1
Gemma
Multi-turn
551.7
567.9
562.3
585.7
603.2
635.0
641.1
662.3
683.4
683.2
Memory
551.7
564.8
600.9
593.8
614.2
655.1
664.4
667.3
688.2
696.4
Appendix
Table H.11: Number of generated tokens on MMLU-pro.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Llama
Multi-turn
665.7
644.4
659.2
683.2
721.5
699.2
697.8
689.6
697.8
690.8
Memory
665.7
614.8
671.1
678.5
667.1
673.4
660.3
646.5
651.6
627.4
In-place
665.7
421.3
351.0
283.8
312.3
297.0
292.7
306.9
241.3
266.8
Gemma
Multi-turn
822.6
811.8
756.1
731.8
773.5
736.9
796.8
809.3
806.9
820.0
Memory
822.6
796.5
797.6
774.2
815.5
837.2
816.6
835.6
823.3
815.7
Appendix
Table H.12: Number of generated tokens on GPQA.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Llama
Multi-turn
1685.8
1237.7
1502.3
1597.5
1535.5
1558.8
1558.4
1623.8
1572.2
1600.6
Memory
1685.8
1181.6
1118.8
1164.6
1182.5
1176.5
1175.7
1169.2
1133.1
1144.5
In-place
1685.8
746.2
566.9
523.3
501.3
528.7
529.6
563.8
582.7
662.8
Gemma
Multi-turn
1123.1
1073.6
1090.5
1096.2
1104.9
1118.8
1129.5
1140.4
1147.1
1143.0
Memory
1123.1
1207.0
1194.1
1263.0
1251.1
1271.5
1299.5
1313.1
1304.8
1318.6
Appendix
Table H.13: Number of generated tokens on ZebraLogic.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Gemma
Multi-turn
0.000
0.028
0.078
0.148
0.271
0.421
0.556
0.650
0.728
0.771
Memory
0.000
0.007
0.028
0.052
0.078
0.105
0.135
0.167
0.199
0.234
In-place
0.000
0.031
0.115
0.265
0.441
0.582
0.712
0.816
0.868
0.906
Qwen
Multi-turn
0.003
0.022
0.071
0.150
0.249
0.356
0.468
0.566
0.645
0.690
Memory
0.004
0.025
0.073
0.166
0.251
0.348
0.434
0.520
0.600
0.665
Appendix
Table H.14: Grid accuracy of LLMs on ZebraLogic with top- 4 feedback.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Gemma
Multi-turn
0.000
0.013
0.035
0.070
0.109
0.156
0.208
0.266
0.325
0.390
Memory
0.000
0.005
0.018
0.033
0.044
0.058
0.078
0.089
0.101
0.120
In-place
0.000
0.013
0.057
0.103
0.167
0.252
0.334
0.421
0.494
0.582
Qwen
Multi-turn
0.004
0.013
0.029
0.059
0.093
0.136
0.188
0.229
0.276
0.322
Memory
0.004
0.015
0.032
0.071
0.119
0.157
0.217
0.278
0.342
0.395
Appendix
Table H.15: Grid accuracy of LLMs on ZebraLogic with top- 2 feedback.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Gemma
Multi-turn
0.272
0.435
0.567
0.681
0.779
0.848
0.896
0.927
0.947
0.959
Memory
0.272
0.350
0.411
0.464
0.505
0.528
0.548
0.571
0.586
0.603
In-place
0.272
0.432
0.573
0.698
0.794
0.859
0.914
0.944
0.963
0.972
Qwen
Multi-turn
0.263
0.417
0.543
0.652
0.736
0.806
0.859
0.891
0.921
0.935
Memory
0.264
0.406
0.518
0.618
0.690
0.750
0.794
0.835
0.866
0.891
Appendix
Table H.16: Cell accuracy of LLMs on ZebraLogic with top- 4 feedback.
Method
Number of turns
0
1
2
3
4
5
6
7
8
9
Gemma
Multi-turn
0.272
0.367
0.441
0.511
0.575
0.629
0.679
0.723
0.761
0.793
Memory
0.272
0.311
0.347
0.376
0.401
0.428
0.445
0.461
0.482
0.501
In-place
0.272
0.359
0.434
0.510
0.580
0.642
0.702
0.754
0.793
0.832
Qwen
Multi-turn
0.264
0.350
0.421
0.482
0.538
0.585
0.629
0.666
0.698
0.730
Memory
0.264
0.339
0.410
0.471
0.529
0.581
0.628
0.669
0.703
0.735
Appendix
Table H.17: Cell accuracy of LLMs on ZebraLogic with top- 2 feedback.
Figure I.1: Prompt format used for memory-based feedback in MATH-hard, MMLU-pro free-form, GPQA free-form, and LiveCodeBench. The system prompt is identical to that in multi-turn feedback.
Figure I.2: Prompt format used for LLM-as-a-judge in MATH-hard, MMLU-pro free-form, and GPQA free-form.
Figure I.3: Prompt format used for the feedback agent in empirical experiments.
Figure I.4: Prompt format used for in-place feedback agent in MATH-hard, MMLU-pro free-form, and GPQA free-form.
Figure I.5: Prompt format used for in-place feedback agent in LiveCodeBench.
Figure I.6: Input template used for ZebraLogic.
Figure I.7: Rule-based feedback template in ZebraLogic.
Figure I.8: Prompt format used for in-place feedback agent in ZebraLogic.
Figure I.9: In-place feedback example for the MATH-hard dataset.
Figure I.10: In-place feedback example for the MATH-hard dataset.
Figure I.11: In-place feedback example for the GPQA free-form dataset.
Figure I.12: In-place feedback example for the MMLU-pro free-form dataset.
Figure I.13: Failure example of multi-turn refinement on the MATH-hard dataset: corrupting correct content.
Figure I.14: Failure example of multi-turn refinement on the MMLU-pro free-form dataset: ignoring feedback.
Figure I.15: Failure example of multi-turn refinement on the MMLU-pro free-form dataset: introducing a new error.
Figure J.1: Screenshot of the summarization page. Participants paste a passage from their chosen paper and click Summarize to obtain an initial summary from the model.
Figure J.2: Screenshot of the edit decision page. Participants record the edits they plan to make. This serves as a memo to help them stay organized during the subsequent interaction.
Figure J.3: Screenshot of the mode selection page, where participants choose the editing mode for the upcoming task.
Figure J.4: Screenshot of the multi-turn mode interface, used when participants provide feedback through standard multi-turn feedback.
Figure J.5: Screenshot of a model response in the in-place feedback mode. Clicking the button below the response opens an editor that allows participants to perform an in-place edit on the response.
Figure J.6: Screenshot of the in-place feedback interface. Participants directly modify the model’s response and click Continue Generation to resume generation from the edited context.
Figure J.7: Screenshot of an example response produced under in-place feedback. The blue span indicates the participant’s in-place edit, and the green span indicates the continuation subsequently generated by the model.
Large language model reliability studies whether outputs remain correct, calibrated, robust, and controllable across prompts, contexts, and deployment conditions.
Large language models struggle to reliably identify and correct errors in their own reasoning. Unlike prior training-based approaches that fine-tune an LLM to generate revisions or feedback, we learn where to intervene in failed rollouts and determine how to redirect them. To choose where to intervene, we train a 130K-parameter MLP head on a frozen encoder using only final-answer correctness. For redirection, we find that under a fixed generation budget, the tested inline injections fail to reliably redirect reasoning, whereas presenting the same instruction in a new user turn changes the model's course. The resulting correction framework, UPTURN (User-Prompt TURN injection at a learned position), requires no LLM fine-tuning: it retains a selected prefix, injects an instruction as a new user turn, and regenerates the suffix. Across four reasoners and six math benchmarks, UPTURN improves average accuracy in every setting over a 32-rollout baseline. It outperforms self-correction and reflection-token injection baselines under matched correction budgets, transfers across reasoners and to GPQA-Diamond without retraining, and complements GRPO and self-correction methods.
Jiwon Jeon, Myungsik Cho, Jeonghye Kim +1
Korea Advanced Institute of Science and Technology (KAIST)
Closed-loop revision is increasingly used in large language model (LLM) applications, but failures may reflect incomplete feedback or ineffective responses to correct feedback. We introduce a fixed-budget revision protocol with deterministic verifiers that report all remaining violations across exact-length, lexical, and compositional constraints. Fixing feedback correctness and completeness isolates model-side revision behavior. Across 19 open- and closed-source models, controller-level mean final joint success ranges from 17.4% to 99.8%, with substantial cross-model gaps persisting under identical initial drafts. Controlled experiments reveal reproducible model-specific responses to exact feedback. Post-training and scale reshape these responses without consistently bringing them closer to exact correction. Across all constraint families, failed trajectories often repeat earlier outputs, and prior recurrence is associated with lower subsequent recoverability. Matched-state interventions show that removing earlier dialogue while holding the current draft and feedback fixed changes recurrence escape without reliably improving final success; effects depend on the model, task, and trigger-state composition. Exact feedback makes revision errors observable, but does not make the closed loop reliable. Code and reproduction instructions: https://github.com/kevinjiang0121-cyber/exact-feedback-code.
Haitong Jiang, Chunlin Liu, Yile Wang +1
College of Computer Science and Software Engineering, Shenzhen University
Recent work shows that LLM agents struggle to correct errors in their own reasoning traces yet show markedly higher correction rates when identical claims appear under external sources. We ask whether this asymmetry reflects a capability deficit or a role-label artifact: does an agent's willingness to correct a wrong claim depend causally on the chat-template role that carries it, rather than on the claim's content? Our setup keeps the erroneous claim byte-identical across all conditions (SHA-256 verified) and varies only its wrapping role: the agent's own \role{<thought>}, a \role{user} message, a \role{tool} response, or a \role{system <memory>} block. Across 13 model-domain cells covering seven model families and three domains (n=30 paired tasks per cell), relabeling the claim from \role{<thought>} to an external role lifts the explicit-correction rate by 23 to 93 percentage points, with 10 of 13 cells reaching p<0.001. Further experiments confirm that the effect is asymmetric, mechanistically decomposable, and robust across domains. The failure to self-correct is not a cognitive deficit; it is a chat-template artifact. We exploit this artifact by designing a prompt-structure-only intervention that requires no training and no model modification, with its strongest role label being domain-dependent: \role{<memory>} dominates on math, while a plain \role{user} message dominates on logical deduction.