TextBFGS: Quasi-Newton Optimization for Discrete Executable Text via Gradient-Operator Retrieval

TL;DR

TextBFGS addresses the inefficiency of first-order text optimization by introducing a gradient-based, second-order approach for discrete text. It constructs a Hessian-proxy memory (HPKB) of gradient–operator pairs and retrieves abstract operators using gradient similarity, enabling a One-Pass Newton-style update $Δx_t \approx \mathcal{T}(g_{t-1}) \otimes g_t$. The method supports online learning by refining the memory with new $(g_t, \mathcal{O}_t)$ tuples after successful updates. Empirical results on code optimization benchmarks (HumanEval-Hard, MBPP-Hard) show higher pass rates with fewer model calls and strong cross-domain transfer, outperforming TextGrad baselines and input-based retrieval. This work provides a memory-aware, curvature-informed optimization framework for efficient editing of executable text.

Abstract

Optimizing discrete executable text such as prompts and code has recently been framed as a gradient-based process, effectively translating backpropagation concepts to the semantic space. However, existing methods predominantly operate as first-order optimizers akin to Stochastic Gradient Descent, which are suffering from slow convergence and instability because they neglect the semantic curvature of the optimization landscape. To bridge this gap, we introduce TextBFGS, a second-order framework to implement a Quasi-Newton optimization method for discrete text. Unlike traditional memory-based approaches that retrieve similar textual instances, TextBFGS approximates the inverse Hessian matrix by retrieving Gradient-Operators from the memory of pre-learned successful trajectories. Specifically, given a textual gradient feedback, TextBFGS identifies historical correction patterns from the optimization knowledge base and tries to apply these abstract operators to the current variable. This mechanism enables a One-Pass Update, combining feedback generation and second-order correction into a single inference step. Empirical evaluations on code optimization across diverse domains (e.g., HumanEval, MBPP) demonstrate that TextBFGS significantly outperforms first-order baselines. It achieves superior pass rates with fewer model calls and exhibits strong cross-task transferability, thus establishes a mathematically grounded paradigm for efficient, memory-aware text optimization.

Figures (2)

• Figure 1: The schematic overview of the proposed TextBFGS framework. The process consists of three key phases: (1) Hessian-Proxy Retrieval: Instead of retrieving based on input similarity, TextBFGS retrieves abstract optimization operators $\mathcal{O}_{\text{ref}}$ based on gradient similarity from the knowledge base. (2) One-Pass Update: The LLM receives the current variable $x_t$, execution results $E_t$, and retrieved operators $\mathcal{O}_{\text{ref}}$ to simultaneously generate an explicit diagnosis (<GRADIENT>), a general correction rule (<OPERATOR>), and the improved variable (<IMPROVED>) in a single inference step. (3) Online Learning: Upon successful validation (Evaluation), the new gradient-operator pair is injected back into the memory, allowing the optimizer to evolve and accumulate debugging wisdom.
• Figure 2: Schematic visualization of optimization trajectories in a semantic space. TextGrad (Red) operates as a first-order SGD optimizer, exhibiting inefficient oscillation and getting trapped in a local optimum. In contrast, TextBFGS (Blue) adopts a Quasi-Newton approach. It utilizes prior gradient information to get Hessian-Proxy by retrieving successful optimization operators. This process acts as a rectification mechanism (Green), allowing TextBFGS to dampen oscillations and bypass local optima, thereby achieving faster convergence to the global optimum.