acceptodds
Under review as a conference paper at ICLR 2027

ReFold: Training-Free Reversible Inter-Turn Context Folding for Long-Horizon Agents

10 views

Abstract

Long-horizon LLM agents act on an append-only interaction history that is re-sent to the model at every step, so the context and its cost grow with steps until the sessions exceed the context window. Existing methods manage the context through context requirement prediction, relying on additional model calls, heuristic rules, or trained policies. However, these predictive approaches introduce runtime overhead, invalidate prefix caches, and permanently discard content with no guarantee of recovery. To overcome these limitations, we introduce **ReFold**: a *training-free* rendering layer that preserves the underlying interaction history while compressing only the model's rendered context. It removes two kinds of inter-turn redundancy without an auxiliary predictor: content an earlier turn already displayed, replaced by a stub, and turns the agent itself reports finished, folded into a one-line note. Both operators use chunked rendering, rewriting the cached prefix once every few steps rather than at every step. Every removal is strictly reversible, a wrong removal costs one restore from the history rather than permanent content loss. Because it operates at the rendering layer, ReFold is plug-and-play across standard ReAct-style harnesses. Evaluations across five long-horizon benchmarks and two frontier LLMs demonstrate that ReFold reduces token consumption by up to and halves the KV-cache memory per session without degrading task success rates. Under capped context budgets, it avoids up to % of forced compactions. Under concurrent serving workloads, it reduces request queuing delays by up to %, accelerating inference by up to , while cutting inference costs by up to .

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM Agents, Long-Horizon Agents, Context Management, Context Compression, Agentic Coding, KV-Cache Memory, Training-Free, Reversible Folding

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_HJCfOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes ReFold, a training-free context management technique for long-horizon LLM agents. It compresses the context passed to the model while preserving the original interaction history through Deduplication, STALE-based Folding, Chunked Rendering, and Restoration.

Across five benchmarks, the paper reports substantial reductions in token consumption and KV-cache usage while maintaining comparable aggregate task success rates. Its vLLM-based serving experiments also demonstrate improved prefix-cache reuse through chunked rendering and reduced scheduling delays under high concurrency due to lower KV-cache pressure.

Critical strengths

S1. Practical and Meaningful Serving Improvements

ReFold offers a practical approach to context management that requires neither additional training nor auxiliary LLM calls. Beyond reducing token consumption, the paper demonstrates meaningful system-level benefits in a vLLM-based serving environment. In particular, reducing per-session KV-cache occupancy alleviates memory contention under high concurrency, leading to substantial improvements in scheduling delay, task completion time, and inference cost.

I consider this an important strength because the paper connects context compression to actual serving efficiency rather than relying solely on token reduction as a proxy.

S2. Comprehensive Experimental Evaluation

The evaluation covers five benchmarks, two backbone models, multiple context budgets, and varying concurrency levels. The authors also compare ReFold with LLMLingua-2, SWE-Pruner, and AgentDiet under the same harness in Appendix D.4, strengthening the empirical comparison.

ReFold achieves substantial reductions in token usage and KV-cache footprint while maintaining comparable aggregate task success rates across the main benchmarks. The ablation studies further demonstrate the contributions of Folding, Deduplication, and Chunked Rendering. These results provide credible evidence of the practical value of the proposed system.

Critical weaknesses

W1. Missing Baselines for STALE-Based Folding

ReFold modifies the agent's prompt to generate PROGRESS/STALE metadata and uses the selected indices to fold previous turns (Section 3.2). Appendix E demonstrates that Folding contributes substantially to token and KV-cache savings.

However, the experiments do not separate the effect of the modified prompt on task execution from the effect of context compression. They also do not show whether model-selected STALE indices are more effective than simpler folding policies.

A metadata-only baseline using the same prompt without compression, together with a static or heuristic folding baseline under matched prompting and chunking conditions, would help isolate the contribution of STALE-based Folding.

W2. Limited Evidence for Task-Success Preservation on SWE-bench Pro

In Table 1, the baseline solves only 5/50 (10%) and 6/50 (12%) SWE-bench Pro tasks. With nearly 90% of tasks already failing, these results provide limited evidence about whether ReFold preserves the ability to solve difficult tasks.

Appendix A.4 provides useful evidence of run-to-run variability, including task-level success changes. However, it does not directly analyze which SWE-bench Pro tasks regress when switching from Base to ReFold. The reported aggregate success rates are comparable, but task-level regressions could still be hidden by changes in which tasks are solved.

A larger SWE-bench Pro evaluation or a stronger backbone with a higher baseline success rate would make the task-success preservation claim more convincing.

W3. Technical Reversibility Does Not Guarantee Effective Information Recovery

ReFold preserves the original interaction history, but this does not guarantee that the agent recognizes when folded information is needed or restores it in time. In long-horizon tasks, previously discarded information may become relevant again, and restoration may occur only after incorrect decisions have already been made.

Appendix C.3 demonstrates a successful recovery through command re-execution, but does not establish how reliably recovery occurs across trajectories. Similarly, Figure 4c evaluates technical recoverability rather than actual information use or task preservation.

An analysis of missed or delayed recovery and its impact on information retrieval and task success is needed.

Questions for authors

Q1. Isolating the Contributions of Prompting and Folding

Could the authors report a metadata-only baseline that uses PROGRESS/STALE prompting without compression? Could they also compare ReFold with a simple static or heuristic folding policy using the same prompt and chunked rendering?

Q2. Task-Level Regressions

How many tasks solved by Base fail under ReFold, and vice versa? For tasks solved by Base but not by ReFold, could the authors examine whether the failures involved missing information from folded turns? How do these failures compare with the task-level fluctuations reported in Appendix A.4?

Could the authors also strengthen the SWE-bench Pro evaluation with more tasks or a stronger backbone?

Q3. Reliability of Information Recovery

How frequently do agents actually recover folded information, and how often is necessary information never recovered or recovered only after incorrect decisions?

For tasks solved by Base but not by ReFold, could the authors analyze whether missing information or delayed recovery contributed to the failures? Could they also directly evaluate the agent's ability to retrieve and use information from earlier turns after folding?

11 comments
AuthorsOpenReview ↗

Response to Reviewer HJCf

We thank the reviewer for the careful and constructive review. We ran the suggested controls and analyses, and we reply in three parts below:

  1. W1 / Q1: Separating the prompt from folding, and agent-selected STALE vs. simpler policies
  2. W2 / Q2: Task-level regressions and SWE-bench Pro
  3. W3 / Q3: Reliability of information recovery
AuthorsOpenReview ↗

W1 / Q1. Separating the prompt from folding, and agent-selected STALE vs. simpler policies.

All runs below use our default setting: SWE-bench Verified, Qwen3.6-27B, 50 tasks, full context window, w = 8.

(a) Does the prompt alone contribute to the results?

We find that the prompt alone does not account for the savings. With the prompt but no compression, the KV cache stays at the base level and task success is not hurt. The savings come from the operators.

MethodResolveStepsTokens (k)KV cache (GiB)
base34508591.66
prompt only (no compression)35 (+1)43 (−14%)1,029 (+20%)1.67 (+1%)
ReFold35 (+1)40 (−20%)477 (−44%)0.80 (−52%)

(b) Does the agent choose well what to fold?

In our experiments, it does. The agent writes its PROGRESS note and STALE selection in the same turn, so a simpler policy can take over from the agent in two ways; we tested both, and each performs worse than the agent's own choice.

Replacing both PROGRESS and STALE. With neither the agent's notes nor its selection, the policy is essentially observation masking (mask), the static alternative the reviewer suggests, which Figure 2 evaluates at a 16k budget. Masking rewrites old observations at every step, so it keeps invalidating the prefix cache: the cache hit falls to 23%, and the lost cache alone adds 5.1¢ per task, 31% of its cost. Even at its best setting, it resolves only 17 of 50 tasks, under half of what compact resolves at the same budget (Appendix B.2, Table 8).

Replacing only STALE. The agent must still write PROGRESS at every step, and a rule then overrides its STALE choice. We use the simplest such rule, a random sample of the same size from the same window, to test whether the agent's choice is selective. As the reviewer suggests, the prompt and chunked rendering stay fixed. Compared with the agent's own choice, random selection leads the agent to re-run 55–72% more folded commands and use 32–37% more tokens. Task success is only slightly lower, within run-to-run noise, likely because even when a useful step is folded, its PROGRESS note tells the agent what it accomplished, so the agent can continue from that summary or restore the full turn if it needs a missing detail. This control comes from a separate run, so its base and ReFold rows differ slightly from (a).

STALE sourceResolveStepsTokens (k)KV cache (GiB)Re-runs of folded steps
base36487741.55—
agent (ReFold)35 (−1)40 (−17%)421 (−46%)0.74 (−52%)128
random (seed 0)33 (−3)50 (+4%)576 (−26%)0.75 (−52%)198
random (seed 1)32 (−4)43 (−10%)557 (−28%)0.70 (−55%)220

We have added both controls to Appendix E.2 (Table 13).

AuthorsOpenReview ↗

W2 / Q2. Task-level regressions and SWE-bench Pro.

(a) Which tasks flip.

We agree that aggregate success rates can hide task-level regressions. Appendix A.4 reports task-level flips on SWE-bench Verified between two runs of base and of ReFold. For the other four benchmarks of Table 1 (Qwen3.6-27B), the per-task outcomes are:

BenchmarkBaseReFoldLost (base only)Gained (ReFold only)
SWE-bench Pro56 (+1)12
Multi-SWE-bench2525 (±0)33
Terminal-Bench 1.02323 (±0)22
Terminal-Bench 2.12326 (+3)36
Total7680 (+4)913

On no benchmark does ReFold lose more tasks than it gains on Qwen3.6-27B, and overall it gains slightly more than it loses. These flips are within the task-level fluctuation of Appendix A.4, where 2–7 tasks flip in each direction between two identical runs of one configuration. We have added this table to Appendix A.4 (Table 6b).

(b) Do the losses come from folded information?

We ran the 9 lost tasks again in the same setting. They fall into three groups:

On a repeat runTasks#
ReFold solves itwebclients-0d0267 (Pro), bytes-721 (MSB), sam-cell-seg (TB 2.1)3
Base also fails itCatch2-2849 (MSB), ponyc-1486 (MSB), llm-inference-batching-scheduler (TB 1.0)3
Loss reproducespuzzle-solver (TB 1.0), overfull-hbox (TB 2.1), mailman (TB 2.1)3

Appendix D.4 walks through the 3 losses that reproduce: in each, the task statement and the files that matter either stay unfolded or are re-read when needed, so we found none of them to come from folded information.

(c) SWE-bench Pro with a stronger backbone.

Following the reviewer's suggestion, we ran Claude Opus 5.5 on the same 50 SWE-bench Pro tasks and have added the result to the main text (Table 1):

MethodResolveLost / GainedStepsTokens (k)Cost (¢)
base30—11230.928.2
ReFold31 (+1)3 / 410 (−9%)140.9 (−39.0%)27.5 (−2.3%)

With base solving 30 of the 50 tasks, losses and gains remain balanced (3 lost, 4 gained), so ReFold preserves task success on a stronger backbone as well, while cutting tokens by 39%.

Reviewer_cDxGOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

The paper introduces ReFold, a training-free context-management method for long-horizon LLM agents. ReFold preserves the original interaction history while reducing the context presented to the model through two operators: deduplicating repeated observations and folding turns that the agent marks as no longer needed. Chunked updates limit prefix-cache invalidation, and omitted content remains accessible through a restoration mechanism. It first analyzes five context-management strategies alongside an uncompressed baseline, then evaluates ReFold on five software-engineering and terminal benchmarks using two Qwen models. The main experiments report 18–60% lower token consumption and 30–58% lower peak per-session KV-cache memory, with similar observed task-success counts. Additional experiments examine constrained context budgets, concurrent serving, component ablations.

Critical strengths
  1. The paper conducts a comprehensive analysis of 5 different context management methods: mask, prune, recall, compact, clip on multiple aspects: KV-cache footprint, peak kv-cache, cost, overhead, prefix-cache reuse and the fate of evicted observation tokens.

  2. It propose ReFold, which combines a lightweight implementation with consistent empirical resource savings. Across 5 benchmark on 2 model combinations, resource consumption decreases while observed task-success counts remain close to the baseline. These results support the method’s usefulness as an addition to existing agent systems.

Critical weaknesses
  1. Insufficient discussion of context-window limits. ReFold reduces context growth but does not guarantee that long trajectories remain within a fixed context window.
  2. The paper lacks a dedicated limitations section. A clearer discussion of failure cases and applicability would help readers assess the method.
Questions for authors
  1. How is compact + ReFold implemented? Can the agent still restore earlier turns after compaction?
  2. Does the optimal chunk size (k) depend on the task or model?
  3. From Table 2, it seems like the task resolvability doesn't change much with variant context window size. Does it mean that the entire task context is shorter than the shortest window (16k)? or the task not complex enough to test out the performance of context compression?
  4. How does ReFold compare with recoverable compaction methods such as LCM?
  5. Minor comments: (1) The ordering of rows in Table 2 could be clearer, grouping them by experimental setting would improve readability. (2) The hyperlinks in the PDF do not work.
3 comments
AuthorsOpenReview ↗

Response to Reviewer cDxG

We thank the reviewer for the thoughtful review and the encouraging comments.

W1. Context-window limits. We agree that ReFold slows context growth but does not bound it. Under a fixed window, ReFold runs on top of compaction (compact + ReFold, Table 2): compaction keeps the context within the window, and ReFold makes it trigger far less often. Compactions per task fall by 92% at 32k, 83% at 24k and 33% at 16k. We discuss this in a new Limitations and Future Work paragraph at the end of the Conclusion.

W2. Limitations. As suggested, we have added a Limitations and Future Work paragraph to the Conclusion of the revised PDF, covering failure cases and applicability.

Q1. compact + ReFold. Compaction triggers when the prompt reaches 75% of the budget and replaces the oldest 60% of the not-yet-summarized turns with one summary written by the same model, keeping the most recent turns. In compact + ReFold, compaction still cuts whole turns, and the summarized turns join ReFold's folded set. Earlier turns stay restorable: compaction never edits the interaction history, and the summary exists only in the rendered context, so restore <step> returns their original output, as for any folded step.

Q2. Chunk size k. We did not tune k per task or model: the same k = 3 is used for all three models and all five benchmarks, and it reduces tokens and KV cache in all ten settings of the two Qwen models in Table 1, with resolve within run-to-run noise. We re-ran the sweep of Figure 4b with Qwen3.6-27B on all 50 SWE-bench Verified tasks instead of 20:

k1235812
Resolve363438363739
KV cache (GiB)0.880.810.700.790.911.12
Re-runs of folded steps3501691501964235

Within a setting, results are insensitive around k = 3: resolve stays within run-to-run noise for every k, and the KV cache is lowest at k = 3 and close to it at k = 2 and 5.

Q3. Flat resolve in Table 2. The tasks are much longer than 16k, and we should have made this clearer in the paper. Resolve rate looks flat in Table 2 because every setting runs on top of compaction (compact), which keeps the tasks solvable. Without any compaction, both the number of resolved tasks and the number of tasks that exceed the window depend strongly on the context window size (Qwen3.6-27B, 50 SWE-bench Verified tasks; resolved / tasks that exceed the window):

Context window8k16k24k32k64k256k
base1 / 494 / 4319 / 2532 / 1035 / 037 / 0
ReFold (no compaction)9 / 3821 / 1432 / 332 / 138 / 039 / 0

As the window shrinks, base drops from 37 resolved at 256k to 1 at 8k, which shows that the tasks are long enough to test context compression. ReFold alone degrades much more slowly, because it keeps most tasks within the window. Table 2 does not compare base and ReFold without compaction, because many runs exhaust the window early and stop: their tokens and KV cache then measure where the run was cut off, not what the task needs. To reflect real use, Table 2 adds compaction to both sides (compact vs. compact + ReFold), so that no task exhausts the window. We have added this table to Appendix D.3 of the revised PDF.

Q4. Comparison with LCM. Thank you for this pointer. ReFold is complementary to LCM (Ehrlich and Blackman, 2026) and could run on top of it, just as it runs on top of compact. On its own, compact is lossy: once a turn is summarized, its original content is never shown again. With ReFold on top, summarized turns join the folded set and stay verbatim in the append-only history, and the agent can bring any of them back with restore <step> (Q1). In this sense, compact + ReFold (Table 2) is a recoverable compaction, like LCM. The two differ in how they recover: LCM condenses its summaries into a hierarchy and expands them through sub-agents, while ReFold restores a step directly into the agent's own context. The larger difference is that ReFold also folds before the context reaches the compaction threshold: the agent marks the steps it has finished as STALE, and each fold note is built from that step's PROGRESS line, so folding needs no summarization call. As a result, compaction is triggered less often (W1). LCM is discussed in our related work, among external-memory methods.

Q5. Minor comments. Thank you for both suggestions. (1) We have regrouped Table 2 into three labeled blocks: context window budget, concurrency load, and joint budget and concurrency. (2) The links were typeset without color, which made them easy to miss; the revised PDF shows them in color.

We hope these responses address the reviewer's comments, and we would be happy to discuss any remaining questions.

Just a gentle reminder: as the discussion period closes on November 18, we wanted to check whether our response addresses your questions. In brief, we added a Limitations and Future Work paragraph, results across context windows without compaction (App. D.3), a chunk-size sweep on all 50 tasks, and a discussion of LCM, and we regrouped Table 2 and fixed the links. We would be glad to discuss any remaining concerns.

Thanks for your reply! The response resolve my questions! Good paper.

Reviewer_EpmdOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Targeting the cost issue of long-horizon LLM agents, the paper introduces a training-free layer that preserves the underlying interaction history while compressing the context, named ReFold. ReFold uses Deduplication and Folding operators. With mini-swe-agent and Qwen3.6-27B/35B-A3B, ReFold reduces tokens and per-session peak KV cache. The appendices add a Claude Opus 4.8 run.

Critical strengths
  • The motivation is realistic; context reuse is a costly problem in long-horizon multi-agent systems.

  • ReFold is training-free, which preserves the interaction history while compressing context, using two operators: deduplication and folding.

  • The experiment in Figure 2 over different metrics is illustrative.

Critical weaknesses
  • The baselines in Table 2 can be limited. For example, the method that shortens prompts would also likely relieve the same congestion, but the concurrency experiments compare only base vs. base+ReFold.

  • The gain on frontier models like Claude Opus 4.8 seems to be shrinking, as shown in Table 9, which should be highlighted in the paper's main body.

Questions for authors

It seems only one harness, mini-swe-agent, is tested in the paper. How is the stated "plug-and-play" on others?

2 comments
AuthorsOpenReview ↗

Response to Reviewer Epmd

We thank the reviewer for the positive assessment and the helpful suggestions.

W1. Baselines under concurrency.

Appendix F.2 (D.4 in the submission) compares ReFold with prompt-shortening methods on the same harness, and its KV cache measurements speak directly to this question:

MethodKV cache (GiB)
base1.71
LLMLingua-21.52 (−11%)
SWE-Pruner1.55 (−9%)
AgentDiet (θ = 500 / 150)1.72 / 1.45 (+1% / −15%)
ReFold0.83 (−52%)

Concurrent sessions share one server's KV cache pool. Once the pool is full, new requests wait in the queue, and this is the congestion in Table 2. A method therefore relieves congestion as much as it lowers the KV cache each session holds. These methods shorten tool observations one at a time, but every turn, including the agent's own messages, stays in the context, so they lower the KV cache by at most 15%. ReFold also folds each finished turn, both the agent's message and its observation, so it lowers the KV cache by 52%, which is why it nearly eliminates the queuing delay in Table 2 (at w = 48, 8.96 s → 0.02 s).

W2. Gains on frontier models.

We agree that the Claude evaluation belongs in the main text. Our API provider has deprecated Claude Opus 4.8, so we moved to the newer and more capable Claude Opus 5.5 and ran a larger evaluation on harder tasks, the same 50 SWE-bench Pro tasks as the Qwen models. Claude Opus 5.5 is now a third model in Table 1, in place of the submission's Table 9.

MethodResolveLost / GainedStepsTokens (k)Cost (¢)
base30—11230.928.2
ReFold31 (+1)3 / 410 (−9%)140.9 (−39.0%)27.5 (−2.3%)

ReFold keeps task success, lowers tokens by 39% and lowers cost slightly (−2.3%). The cost saving is smaller than in most Qwen settings, for two reasons. First, Claude finishes a task in far fewer steps (a median of 11 against 20 to 89 for base on the Qwen models), so few turns follow a fold and benefit from it. Second, Claude's provider bills a cache write at 20 times a cache read or more, and every fold turns the cached prompt after it into a cache write, so the token saving translates into a smaller cost saving. ReFold's saving grows with trajectory length (Appendix D.1, Figure 5), so it is largest on the long-horizon tasks where context management matters most.

Q1. Other harnesses.

To check plug-and-play use beyond mini-swe-agent, we ported ReFold to four more frameworks, each through the framework's own context hook (SWE-agent's history processor, OpenHands' Condenser, LangGraph's pre_model_hook, smolagents' write_memory_to_messages), without modifying the framework. Each runs Qwen3.6-27B on 10 SWE-bench Verified tasks.

FrameworkMethodResolveStepsTokens (k)KV cache (GiB)Cost (¢)
SWE-agentbase75420082.9256.1
ReFold6 (−1)65 (+20%)1857 (−8%)1.40 (−52%)47.4 (−15%)
OpenHandsbase47326353.6171.5
ReFold6 (+2)78 (+7%)1802 (−32%)1.95 (−46%)55.2 (−23%)
LangGraphbase5415781.4117.3
ReFold4 (−1)38 (−7%)257 (−56%)0.72 (−49%)9.4 (−46%)
smolagentsbase7363931.1712.2
ReFold6 (−1)26 (−28%)354 (−10%)0.67 (−43%)11.6 (−5%)

In all four harnesses, ReFold plugs in through the existing hook and lowers tokens, KV cache and cost; on 10 tasks, a difference of one or two resolved tasks is within noise. We have added this table to Appendix F.1.

We hope these results address the reviewer's questions, and we are happy to provide more details if helpful.

Thank you again for your review. Kind reminder: as the discussion period closes on November 18, we wanted to check whether our response addresses your questions. In brief, we compared ReFold's KV-cache savings with prompt-shortening methods (App. F.2), moved the frontier-model evaluation into the main text with Claude Opus 5.5 on SWE-bench Pro (Table 1), and ported ReFold to four more agent frameworks (App. F.1). We would be glad to discuss any remaining concerns.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Summary of Revisions

We thank all reviewers for their careful reading and constructive feedback. We have uploaded a revised PDF with the following main changes.

Main text

  • Table 1 adds Claude Opus 5.5 on SWE-bench Pro, in place of the submission's Table 9 (HJCf, Epmd).
  • A Limitations and Future Work paragraph is added at the end of the Conclusion (cDxG).
  • Table 2 is regrouped into three labeled blocks, and links are shown in color (cDxG).

New appendix results

  • A.4 Task-level variability (Table 6b; HJCf)
  • C.4 How often folded information is recovered (Table 9; HJCf)
  • D.3 Context windows without compaction (Table 10; cDxG)
  • D.4 Tasks that base solves and ReFold does not (Table 11; HJCf)
  • E.2 Controls for the prompt and the STALE selection (Table 13; HJCf)
  • F.1 Other agent harnesses (Table 14; Epmd)

The appendix is also reorganized into additional results (D), ablations (E) and extensions (F), so the submission's D.4 is now F.2. Our replies to each reviewer use the revised numbering.

AuthorsOpenReview ↗

Summary of the discussion

We thank the reviewers and the Area Chair for their time and thoughtful feedback throughout the review process. Below is a brief wrap-up of our work and the main updates from the discussion.

Motivation. Long-horizon agents re-send their full interaction history at every step, causing token costs and KV-cache memory to grow steadily over time. Much of this context is redundant, either tool outputs the agent has already seen, or turns the agent itself marks as finished. Existing approaches typically compress context by predicting what can be dropped, which requires extra model calls, breaks prefix caching, and permanently discards information.

Our approach. ReFold compresses only the context rendered to the model while keeping the underlying interaction history intact. Repeated outputs are replaced with short stubs, and finished turns are folded into a one-line note, with any step remaining strictly reversible on demand. Because it requires no training or auxiliary model calls, ReFold plugs directly into existing agent harnesses.

Key results. Across five benchmarks and three models, ReFold cuts token usage by up to 2.5× and halves per-session KV-cache memory while preserving task success rates (Table 1). Under tight context budgets and concurrent serving workloads, it substantially reduces forced compactions and queuing delays, making inference both faster and cheaper (Table 2).

Summary of reviewer feedback and revisions.

  • Reviewer cDxG (Weak Accept) highlighted the comprehensive analysis of context-management strategies and consistent resource savings. We addressed all questions by adding a Limitations section, experiments without compaction, a chunk-size sweep, and a discussion of LCM. The reviewer confirmed that our response resolved their questions ("Good paper.").
  • Reviewer Epmd (Weak Accept) noted the realistic motivation and practical training-free design, asking about concurrent baselines, frontier models, and cross-harness portability. We added comparisons against prompt-shortening methods, evaluated Claude Opus 5.5 in Table 1, and validated ReFold across four additional agent frameworks. (No follow-up reply was received before the deadline.)
  • Reviewer HJCf (Weak Reject) noted that our results "provide credible evidence of the practical value of the proposed system" and raised questions on prompt isolation, task-level regressions, and information recovery. We addressed all ten original questions with new controls and analyses. In subsequent follow-ups, the reviewer felt W1 and W2 were addressed "to some extent" and maintained their score, narrowing W3 first to recovery prior to dependent decisions and then to decisions beyond file edits. We responded to each follow-up, including a new decision-level recovery analysis in Appendix C.4.

Thank you again for the constructive engagement that helped strengthen the paper.

Best regards,
The authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.