🤖 machine learning

CORVUS: Context Optimization and Reduction Via Underlying Synchronization for LLM Coding Agents

CORVUS introduces a novel trajectory architecture for LLM coding agents that decouples file-read actions from their observations by maintaining a synchronized registry of current file contents, thereby eliminating stale snapshots and redundant re-reads to significantly reduce token usage and reasoning cycles while maintaining performance.

Original authors: Mingwei Zheng, David OBrien, Siwei Cui, Pardis Pashakhanloo, Rajdeep Mukherjee, Myeongsoo Kim, Sachit Kuhar

Published 2026-07-28

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Mingwei Zheng, David OBrien, Siwei Cui, Pardis Pashakhanloo, Rajdeep Mukherjee, Myeongsoo Kim, Sachit Kuhar

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a world where you have a super-smart robot assistant that can write computer code, fix bugs, and build entire software programs just by talking to you. This isn't science fiction; it's the reality of "LLM coding agents." These are artificial intelligence models that act like junior developers: they think about a problem, look at files, make changes, and check their work. But here's the catch: these robots have a very short-term memory problem. To remember what they've done, they keep a running diary of every single thought, action, and result. The more complex the job, the longer this diary gets. Eventually, the diary becomes so massive that the robot gets confused, forgets the most important details, and starts making silly mistakes because it's trying to read a 500-page book just to remember what it did five minutes ago. This phenomenon, where too much information makes the AI dumber, is called "context rot."

Enter CORVUS, a clever new system designed to fix this memory mess. Instead of letting the robot's diary grow uncontrollably with old, outdated notes, CORVUS acts like a magical, living library. It realizes that code changes all the time. If the robot reads a file, then edits it, then reads it again, the old note in the diary is useless junk. CORVUS stops the robot from writing down the file's content every single time. Instead, it keeps a "synced list" of the files the robot needs. Before the robot makes a new decision, CORVUS quietly checks the actual computer files, grabs the very latest version, and hands it to the robot. This way, the robot always has the freshest, cleanest information without a diary bloated with duplicate, stale pages. The result? The robot works faster, costs less to run, and makes fewer mistakes, all while keeping its memory light and focused.

The Problem: The "Stale Snapshot" Trap

To understand why CORVUS is a big deal, we first need to look at how these coding agents usually work. Imagine you are trying to fix a leaky faucet, but you are doing it while wearing a blindfold, and you can only see the room through a series of photos you took earlier.

In the traditional method, every time the agent (our robot) looks at a file, it takes a "snapshot" of that file and pastes it into its history log. If the file changes later—because the robot edited it, or because a human developer came in and tweaked it—that old snapshot in the log stays exactly the same. It becomes stale.

The paper's authors found that this creates two major headaches:

Duplicate Reads: Because the old snapshot is buried deep in a long history, the robot often forgets it already looked at the file. It reads the file again, takes another snapshot, and pastes it in. This is like reading the same page of a book five times because you lost your place. In their tests, they found that 26% of the time, the robot was re-reading files it had already seen.
Stale-Context Errors: Even worse, the robot might try to edit a file based on an old snapshot. Imagine the robot sees a line of code that says "Line 10: Turn on the light," but in the real world, that line was deleted five minutes ago. The robot tries to edit "Line 10," fails, gets confused, and has to spend extra time and energy figuring out what went wrong.

The old way of fixing this was "reactive." It's like waiting until your backpack is so full of rocks that you can't lift it, and then trying to throw some rocks out. The paper argues this is too late. The real solution is to stop putting the rocks in the backpack in the first place.

The Solution: The "Living Sync"

The authors propose CORVUS (Context Optimization and Reduction Via Underlying Synchronization). Think of CORVUS not as a diary, but as a live feed.

Instead of pasting the content of a file into the history log, CORVUS uses a special tool called sync_file. When the robot says, "I need to look at speech_recognition.py," CORVUS doesn't copy the text into the log. Instead, it puts a tiny, lightweight note in the log that says: "Sync: speech_recognition.py."

Behind the scenes, CORVUS maintains a Synced File Set. This is a special list of files the robot is currently working on. Before the robot makes any new decision (every single reasoning cycle), CORVUS performs a quick "Context Sync." It goes to the actual computer, grabs the current, latest version of every file on that list, and injects it into the robot's prompt.

This changes everything:

No Duplicates: The robot never sees two versions of the same file. It only sees the one, current version.
No Stale Data: If a file changes, the next time the robot thinks, it gets the new version automatically. It never tries to edit code that doesn't exist anymore.
Lighter Weight: The history log stays small because it only contains the robot's thoughts and actions, not massive blocks of file text.

What They Found: Faster, Cheaper, Smarter

The researchers tested CORVUS on two tough coding challenges: SWE-POLYBENCH_VERIFIED (which includes Java, JavaScript, and TypeScript tasks) and SWE-BENCH PRO (which features complex, enterprise-level problems). They ran these tests on four different powerful AI models, including CLAUDE SONNET 4 and QWEN3-CODER-480B.

The results were impressive, showing that keeping the context fresh makes the AI significantly more efficient:

Less Wasted Reading: CORVUS cut down on duplicate file reads by 22% to 86%. The robot stopped wasting time re-reading files it already knew.
Fewer Steps: Because the robot wasn't getting confused by old data, it finished tasks faster. The number of reasoning cycles (steps) dropped by 15% to 37%. For example, on one model, the steps went from an average of 45.03 down to 28.22.
Shorter Prompts: The final "prompt" (the message sent to the AI to finish the job) was 15% to 32% shorter.
Money Saved: Since AI costs money based on how much text it processes, these savings added up. On some tasks, the cost dropped by up to 50.28%. For instance, a task that cost $5.27 dropped to $2.62.
Speed: The whole process finished up to 40% faster in terms of total time.

Crucially, the paper notes that the robot didn't get dumber by having less text to read. The success rate (how often it fixed the bug correctly) remained comparable to the old method, and in some cases, even improved slightly.

The Big Picture

The authors also checked if CORVUS works with other methods that try to clean up messy histories. They found that CORVUS and these "reactive" cleanup tools are best friends. CORVUS stops the mess from happening at the source (upstream), while the other tools clean up whatever remains (downstream). When used together, they saved even more tokens and money.

In short, CORVUS suggests that for AI coding agents to be truly efficient, they shouldn't just be good at remembering the past; they need to be good at staying connected to the present. By decoupling the action of "reading a file" from the "content of the file," and instead keeping a live sync with the codebase, we can build agents that are faster, cheaper, and less prone to the confusion of "context rot." The paper doesn't claim this solves every problem in AI, but it does show that a simple structural change—swapping a static diary for a live feed—can make a huge difference in how well these digital assistants work.

Technical Summary: CORVUS

Problem: Context Rot and Append-Only Trajectories

Large Language Model (LLM) coding agents operate via an iterative Thought–Action–Result loop, maintaining a "trajectory" (interaction history) as working memory. Conventional agents utilize an append-only trajectory architecture, where file-read actions are tightly coupled with their observations. When an agent reads a file, a point-in-time snapshot of that file's content is permanently appended to the chronological history.

This architecture creates two primary inefficiencies, particularly in long-horizon software engineering tasks:

Duplicate File Reads: As the trajectory grows, relevant file contents become buried in the context ("lost in the middle" phenomenon). Agents frequently re-read files to retrieve information, appending redundant full-file snapshots to the history. Empirical analysis showed that 26% of file-read operations in baseline agents were duplicates.
Stale-Context Errors: Because snapshots are immutable, they do not reflect subsequent edits made by the agent or concurrent human modifications. Agents may attempt to edit code based on outdated line numbers or variable names, leading to failed edits. Recovery requires additional diagnosis cycles and further file reads, exacerbating trajectory bloat.

These issues contribute to context rot, where increasing prompt length degrades model accuracy and reasoning reliability, while simultaneously increasing token costs and inference latency. Existing context management methods are largely reactive, compressing or pruning context only after it has accumulated. They do not prevent the introduction of unnecessary or stale content at the source.

Methodology: CORVUS Architecture

The paper proposes CORVUS (Context Optimization and Reduction Via Underlying Synchronization), a proactive trajectory architecture that decouples file-read actions from their observations. Instead of storing fixed snapshots, CORVUS maintains a synchronized registry of relevant files.

Core Mechanisms

Synced File Set ( $S_t$ ): CORVUS introduces a dynamic registry of files relevant to the current task. When an agent needs to interact with a file, it invokes a new tool, sync_file(fj), rather than read_file(fj).
- The sync_file tool registers the file in the set $S_t$ but appends only a lightweight marker (e.g., "sync: ./path/to/file") to the trajectory history, avoiding immediate inclusion of the file's content.
Context Synchronization Phase: Before every reasoning cycle, a synchronization step refreshes the context. The system fetches the current contents of all files in the synced set from the repository.
Prompt Composition: The prompt for each reasoning step is constructed as:
$P_t = M_{sys} \oplus T_{schema} \oplus H_{t-1} \oplus C_t$
Where $C_t$ is the Synced Context, containing at most one current version of each registered file. This ensures the agent reasons over the latest codebase state without carrying historical, potentially stale, file snapshots in the message history.

This structural change ensures that the trajectory remains synchronized with the actual repository state by construction, eliminating redundant copies and preventing the agent from reasoning over outdated information.

Key Contributions

The paper makes three primary contributions:

Identification of Structural Inefficiency: The authors empirically identify that the standard append-only trajectory architecture causes mutable file contents to be treated as immutable history entries, leading to the accumulation of duplicate and stale snapshots.
Proactive Architecture (CORVUS): They propose CORVUS, which replaces inline file reads with a sync_file mechanism and a pre-cycle context refresh. This guarantees that the prompt contains only the current version of relevant files, preventing trajectory bloat from the source.
Comprehensive Evaluation: The system was implemented on the STRANDS AGENTS framework and evaluated across four LLMs (three proprietary: Claude Sonnet 3.7, 4, 4.5; one open-source: Qwen3-Coder-480B) on two benchmarks: SWE-POLYBENCH_VERIFIED and SWE-BENCH PRO.

Results

Evaluation across 573 instances demonstrated that CORVUS significantly improves trajectory efficiency while maintaining task success rates:

Reduced Redundancy: Duplicate file reads were reduced by 22–86% across all models.
Fewer Reasoning Cycles: The number of reasoning cycles required to complete tasks decreased by 9–37%, with the largest reduction (37.33%) observed on Claude Sonnet 4.5 for SWE-POLYBENCH_VERIFIED.
Shorter Prompts: Final request prompts were shortened by 15–32%, reducing the maximum context window usage.
Token and Cost Savings: Average input tokens per task were reduced by 9–50%. Total token costs were reduced by up to 51% (e.g., from $5.27 to $2.62 per instance for Claude Sonnet 4.5 on SWE-POLYBENCH_VERIFIED).
Runtime Efficiency: End-to-end latency was reduced by up to 40%. The synchronization overhead (local file reads) was negligible compared to the savings from fewer LLM inference cycles.
Task Success: Pass@1 rates remained comparable to baseline agents, with slight improvements observed in three of the four models, indicating that efficiency gains did not compromise correctness.

Compatibility: The paper further demonstrates that CORVUS is complementary to reactive context management methods (e.g., sliding windows, summarization). Combining CORVUS with reactive strategies yields further reductions in tokens and costs, suggesting a hybrid approach is optimal.

Significance and Claims

The paper claims that proactive codebase-trajectory synchronization is a critical, yet previously overlooked, optimization for long-horizon coding agents. By addressing the root cause of context rot—the coupling of mutable file states with immutable history entries—CORVUS enables more efficient and reliable agentic workflows.

The authors emphasize that their approach is distinct from reactive compression; it prevents the accumulation of stale data rather than cleaning it up later. The results suggest that maintaining a synchronized view of the repository allows agents to operate with lighter-weight trajectories, reducing costs and latency while preserving the ability to solve complex software engineering tasks. The paper concludes that this architectural shift is essential for scaling LLM coding agents to enterprise-grade, multi-day development workflows.