acceptodds
Under review as a conference paper at ICLR 2027

KEEPING UP WITH THE CODE: FILE CONTEXT SYNCHRONIZATION FOR CODING AGENTS

Abstract

Coding agents change a repository while working, but their prompts usually keep every earlier file read. The prompt therefore accumulates duplicate code and code made stale by later edits. Existing compression methods ask which history is useful; they do not check whether that history is still true. We introduce LiveState, a training-free context layer that keeps file observations synchronized with the repository. It replaces old read outputs with stable pointers to a bounded panel containing only the regions the agent inspected. After an edit, LiveState finds each region in the current file and refreshes its text; if the match is uncertain, it hides the region rather than show stale code. On SWE-bench Verified, LiveState reduces mean turns for all eight models from three providers, while accuracy and token use vary by model. Claude 5 Fable matches baseline pass@1 ( points) with fewer turns, and Gemini 3 Flash gains points (paired 95% CI ). The other Claude models trade – points for – fewer turns and – fewer tokens. On the longer-horizon DeepSWE benchmark, Fable keeps pass@1 within points while using fewer turns and fewer tokens, and within an 8M-token budget it resolves of tasks versus for the baseline. Keeping file context current is therefore not just prompt shortening: it also changes how agents act.

Primary area:
foundation or frontier models, including LLMs
Keywords:
coding agents, context management

Reviews

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

This paper identifies stale references to files or file sections in the chat context of coding agents as a potential problem and proposes "LiveState," a context management tool to find and update stale file observations. LiveState replaces file reads in the context with a live updating panel containing one entry per file read and the latest text around the line ranges the agent has read. They obtain the latest updated state by relying on git to identify and replace stale files by reusing agent bash tool calls and adding hidden git commands to them (hidden in the sense that the agent never sees the git outputs) and updating the changed files among those that the agent has read. Their method is primarily positioned as an efficiency trick complementary to or stackable on top of relevance based compaction, since it might sometimes slightly hurt performance.

Critical strengths
  1. Sound experimentation. The authors evaluate the proposed method over multiple benchmarks and for strong frontier backbones
  2. Better efficiency. LiveState produces performance benefits in some cases (e.g. Gemini 3 Flash) and in almost all cases and reduces number of turns and tokens making it more efficient
Critical weaknesses
  1. Reported tokens/efficiency reductions won't translate. The main benefit of this paper is boosting efficiency by reducing number of tokens and turns used by the model but the authors themselves acknowledge that token savings might not translate to actual benefit since they lead to greater cache misses
  2. Missing crucial baselines/ablations. This paper explicitly positions itself as something that can be added on top of relevance based compaction. However there are no comparisons against it (performance vs token/turn reduction benefits) and whether once you stack it on top of compaction the token savings still persist or not. In general it is also not really compared to any other technique. All comparisons are just the base model with and without LiveState. It is hard to contextualize the benefits of this technique relative to past work.
  3. Lack of technical and analytical novelty. The core idea/approach of this paper is really simple context management. While in principle a simple inervention isn't inherently bad, but for them to be novel and interesting they should be surprising or lead to surprising outcomes and be accompanied with really insightful analysis. This paper misses on both counts. The results are not unexpected and the analysis doesn't uncover or explain any novel behavior shown by coding agents. This weakness is a bit more opinionated (and related to research taste) so feel free to discard this.
  4. Claudeisms in text. Uninformative AI sounding phrases like "accounting identity, not a causal split" spoil the reading experience and make it harder to understand the text. I highly encourage the authors to find these cases and rewrite them manually with more intentional and meaningful text.
Questions for authors
  • Why don't you compare LiveState to compaction and/or do ablations to check if it stacks on top of it?
  • Why don't you actually explore "realized efficiency," similar to TokenPilot (mentioned in the related work) to see if the logical token and turn savings actually translate to a meaningful benefit for deployment?
Reviewer_RFDdOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper observes that coding agents keep all reads in context, so earlier reads go stale once the agent edits any file. It proposes LiveState, a context layer that gives agents a single, up-to-date view of file content. They find that agents take fewer turns when using LiveState, though accuracy and token effects vary by model.

Critical strengths
  • The paper builds on a simple yet overlooked observation (file reads go stale once the agent edits the file) that is not addressed by common methods like compaction. The general idea plausibly extends to other environments where we can directly observe state changes.
  • Across a diverse range of agents, the proposed method saves model turns and tokens.
Critical weaknesses

The only comparison is against the unmodified mini-swe-agent. This matters because any context intervention that discourages re-reading could lead to fewer turns.

Questions for authors

Could you compare vs. other context interventions like observation masking or compaction?

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

This work proposes LiveState, a training-free context layer for coding agents. Old file-read outputs become pointers to one panel that holds only the line ranges the agent read. After edits, each range is re-located and refreshed, or hidden if the match is uncertain, so stale code is never shown. On SWE-bench Verified and DeepSWE, agents use fewer turns for all models, while accuracy changes vary by model.

Critical strengths
  • Broad evaluation: models from three providers, paired confidence intervals, multiple seeds for most models, and a longer-horizon benchmark.
  • Training-free and easy to add to existing scaffolds.
Critical weaknesses
  • The core mechanism is not isolated. Section 3.5 shows the tested system also adds a panel instruction and a repeated-command warning that the baseline lacks. Appendix H attributes net savings to shorter trajectories, not compression. The gains may therefore come from changed agent behavior rather than from keeping context valid.
  • Accuracy drops significantly for several models, together with fewer tests, as Table 4 shows. The paper does not measure how often baseline agents read stale code or fail because of it, which is its core motivation.
  • The only baseline is append-only history. Observation masking, summarization, ACON and tool-result clearing are not compared.
  • The work overlaps with the concurrent CORVUS, which also keeps a synchronized registry of current file contents. The difference between line windows and whole files should be tested, not only described.
  • Token savings are not cost savings. Section 4.8 notes that the panel breaks prompt caching, but cost and latency are not reported. GPT runs use a single seed.
Questions for authors

See Weaknesses.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.