The RSI Tax: When Recursive Self-Improvement Is Not Worth the Cost

Authors: Yitong Zhang, Ang Li, Yisen Wang (Peking University)

---

Summary (Overview)

• Core contribution: The paper introduces the concept of the RSI Tax—the token cost of the recursive self-improvement process itself—and evaluates whether performance gains from RSI justify this cost in end-to-end deployment on continual task streams.
• Key finding: A simple bounded-note baseline called Simple Reflection with Notes (SRN) matches or exceeds the observed accuracy of costly RSI methods (Meta-Harness, EvoSkill, RRSI) while achieving 65.6–71.0% mean total-token savings.
• Cost decomposition: The RSI Tax is decomposed into verification, exploration, and writing costs. Verification accounts for 74.8–93.6% of the aggregate RSI Tax for the three main RSI methods.
• Wasteful expenditure: A substantial share (23.7–63.6%) of the RSI Tax is associated with states or artifacts that are not used later in the evaluated task streams.
• Motivation: The results motivate RSI objectives that jointly optimize the RSI Tax and expected task-execution cost while ensuring continued capability growth.

---

Introduction and Theoretical Foundation

Background

Large language model (LLM) agents use tools for software development and other professional tasks. During continued use, an agent may encounter related tasks within the same repository or application. Retaining useful procedures and lessons from failures could reduce repeated exploration and improve later task performance.

Recursive Self-Improvement (RSI)

RSI uses task experience to update the state an agent carries into subsequent tasks, with fixed model weights. Two categories are distinguished:

1. Memory/skill updates: Maintaining evolving sets of memories or skills (e.g., ReasoningBank, Dynamic Cheatsheet, EvoSkill, SkillOpt).
2. Harness modifications: Modifying instructions, tool interfaces, and control code (e.g., GEPA, Meta-Harness, RRSI, HarnessPro).

The Core Problem

The self-improvement process has its own cost. On a task stream, each update incurs a cost before its value for later tasks is known. The paper defines this cost as the RSI Tax: the token cost of the self-improvement process, counted even when the agent ultimately retains its previous state.

The end-to-end cost is:

$$\text{End-to-end cost} = \sum \text{update tokens} + \sum \text{task-execution tokens}$$

The two terms are coupled: an update can shorten later executions but can also add context or induce longer trajectories.

---

Methodology

Formal Setup

For an ordered task stream $x_1, \ldots, x_T$ with fixed model parameters $\theta$ and state $s_t$ used for task $t$:

$$\tau_{t} \sim \pi_{\theta}(\cdot | x_{t}, s_{t}), \qquad y_{t} = V(x_{t}, \tau_{t}) \in \{0, 1\}. \tag{1}$$

Updates use completed-task history $\mathcal{H}_t = \{(x_i, \tau_i, y_i) : i \le t\}$, restricted by state boundaries and support windows.

Evaluation Metrics

For a prefix of length $t$:

$$Q(t) = \sum_{i=1}^{t} y_i, \quad A(t) = \frac{Q(t)}{t}, \quad N(t) = N_{\text{task}}(t) + N_{\text{RSI}}(t). \tag{2}$$

Cost Accounting

$$N_{\text{task}} = \sum_{c \in \mathcal{C}_{\text{task}}} n(c), \quad N_{\text{RSI}} = \sum_{c \in \mathcal{C}_{\text{RSI}}} n(c), \quad \rho_{\text{RSI}} = \frac{N_{\text{RSI}}}{N_{\text{task}}}, \quad N_{\text{total}} = N_{\text{task}} + N_{\text{RSI}}. \tag{3}$$

RSI Tax Decomposition

The RSI Tax is divided into three categories:

Methods Compared

Six methods evaluated on two backbone models (DeepSeek V4.1 Flash, GPT-6 Luna):

1. Static — no adaptation
2. ReasoningBank — retrieves strategies from completed trajectories
3. EvoSkill — searches over reusable skill folders
4. Meta-Harness — searches over controller code
5. RRSI — regularizes harness changes
6. SRN — simple bounded-note baseline (proposed)

Task Streams

• SWE-Chain-Evo: 7 selected 15-task chains (105 positions), learned state resets per chain
• Terminal-Bench 2.1: 89 heterogeneous tasks in fixed order, learned state retained throughout

The SRN Baseline

SRN maintains a bounded note (2,048 tokens) updated at every four-task boundary using failed tasks:

$$\mathcal{F}_t = \{(x_i, \tau_i, y_i) \in \mathcal{W}_t : y_i = 0\}, \quad m^{+} = \begin{cases} m, & \mathcal{F}_t = \varnothing \\ \text{Limit}_{2048}(G_{\theta}(m, \text{Excerpt}(\mathcal{F}_t))), & \text{otherwise}. \end{cases} \tag{7}$$

SRN performs no extra task sampling, candidate validation, or retrieval search.

---

Empirical Validation / Results

Accuracy and End-to-End Cost

Table 2: Accuracy (%) and total token cost (millions) across four settings

Key results:

• SRN achieves the highest accuracy in 3 of 4 settings and ties in the fourth.
• SRN uses the fewest total tokens in 3 of 4 settings (second-fewest in the fourth).
• Mean token reductions vs. Meta-Harness: 65.6%; vs. EvoSkill: 71.0%; vs. RRSI: 68.2%.
• SRN's update calls account for less than 0.4% of its total tokens.

RSI Tax Rates

Table 3: RSI Tax rate, $100 \times N_{\text{RSI}} / N_{\text{task}}$ (%)

Critical finding: The RSI Tax exceeds task-execution cost for Meta-Harness, EvoSkill, and RRSI in all four settings. At a Tax rate of 100%, the RSI Tax equals task-execution cost.

Verification Dominance

• Verification accounts for:
  • 74.8% of Meta-Harness's RSI Tax
  • 78.1% of EvoSkill's RSI Tax
  • 93.6% of RRSI's RSI Tax
• On the DeepSeek terminal stream, EvoSkill spends 497.45M tokens refreshing its old frontier vs. 182.26M on the 89 arriving tasks — re-evaluation alone costs more than serving the task stream.

Costs Without Subsequent Use

Share of RSI Tax associated with states/artifacts never used later:

---

Theoretical and Practical Implications

Design Implications for Update Policies

An efficient RSI update policy should:

1. Jointly optimize: immediate update cost + expected task-execution cost + cost of subsequent RSI updates
2. Choose selectively: whether to retain current state, update memory/skills, or generate/evaluate harness changes
3. Balance investment: repeated reuse may justify larger initial investments, but this must be weighed against realized needs

Cost Reduction Targets

When verification dominates the RSI Tax:

• Support-task selection becomes a natural target for reducing update cost
• Frontier maintenance should be optimized (EvoSkill's re-evaluation costs more than task execution itself)
• Adaptive validation-task selection offers one approach
• Selective construction of skills and memories based on expected future utility

Methodological Contributions

• The RSI Tax framework provides a unified metric for comparing RSI methods.
• The decomposition (verify/explore/write) enables precise diagnosis of cost inefficiencies.
• The subsequent-use analysis reveals waste: much of the RSI Tax funds artifacts that never get used.

Key Insight

"The results show that the RSI Tax can exceed the cost of executing the task stream... improvements in the deployed agent need not justify the expense of the improvement process."

---

Conclusion

Main Takeaways

1. Competitive accuracy does not require a large RSI Tax. The simple SRN baseline achieves the best or tied-best accuracy with a tax rate below 0.4%, while three mainstream RSI methods incur tax rates of 109–393%.

2. Verification is the dominant cost driver. Repeated candidate evaluation on support tasks consumes more tokens than task execution itself for Meta-Harness, EvoSkill, and RRSI.

3. Much of the RSI Tax is wasted on unused artifacts. 23.7–63.6% of RSI expenditure funds states or artifacts never used in later tasks.

4. Omitting the RSI Tax can reverse cost comparisons. When measuring only task-execution cost, Meta-Harness appears cheaper than SRN on the DeepSeek terminal stream—but including the RSI Tax makes it 3.6× more expensive overall.

Future Directions

• Joint optimization objectives for RSI that balance capability growth, RSI Tax, and expected task-execution cost
• Controlled interventions to measure the effects of reducing each cost component
• Broader evaluation across more models, workloads, orderings, and repeated runs
• Adaptive update policies that forecast costs and select updates accordingly

Limitations

• Two backbone models and limited task chains may not generalize to all settings
• Cost attribution is descriptive: subsequent use does not establish accuracy benefit, and lack of use does not prove the associated calls can be removed without changing outcomes