Multi-Agent Coordinated Rename Refactoring
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "Multi-Agent Coordinated Rename Refactoring".
Jane: Here's the gist of the paper. Multi-agent Coordinated Rename Refactoring presents CoRenameAgent, a novel multi-agent framework that automates coordinated renaming in a new refactoring workflow The primary value of AI agents in software development lies in their ability to extend the developer’s capacity for reasoning and action, not to supplant human involvement CoRenameAgent operates on the key insight that a developer’s initial refactoring is a clue to infer the scope of related refactorings This framework utilizes three individual agents—Scope Inference Agent, Planned Execution Agent, and Replication Agent—to handle the challenges of scoping, execution safety, and propagation across codebases The authors demonstrate that CoRenameAgent achieves a 3.1× F1-score improvement over the previous state-of-the-art on a new benchmark of recent renames Problem Formulation The paper formally defines key terminology to ground the CoRenameAgent workflow, including Conceptual Realignment (T), Individual Rename Refactoring, and Coordinated Renaming A coordinated renaming for a conceptual realignment T is defined as a semantics-preserving, ordered atomic change sequence C = ⟨r(1), r(2),..., r(n)⟩ The formulation reveals three core technical challenges: (1) Scope inference under partial observability, (2) Transformation safety, and (3) Scalable propagation Specifically, the Scoping Challenge involves how to distil a developer’s high-level scope from the initial change and subsequent feedback How the training signal is built The training signal for CoRenameAgent is built through a human-in-the-loop paradigm where developers guide the agent to refine the renaming scope The workflow begins with a seed rename, which serves as a clue for the Scope Inference Agent to infer an explicit, natural-language Declared Scope This scope is then refined based on human feedback, such as go/no-go decisions from the developer The Episodic Memory stores facts about agent experiences and developer feedback to enable on-the-fly adaptation of CoRenameAgent to preferences Where the gains come from The gains in performance stem from the separation of concerns in the multi-agent architecture, where each agent specializes in a distinct part of the refactoring lifecycle The Scoping Challenge is addressed by treating the seed rename as a clue to infer a broad scope, and subsequent interactions refine this scope based on developer preferences The Planned Execution Agent uses this Declared Scope to find program elements and then presents them for human review before executing changes via IDE-based refactoring tools The Replication Agent overcomes the Safe Propagation Challenge by using Declared Scope-driven file discovery, combining semantic search with program-slicing to identify relevant files Evaluation and Practical Utility The evaluation uses two benchmarks: an established RenasBench and a new, uncontaminated Co-renameBench dataset of recent renames CoRenameAgent achieved an F1-score of 54.6% on RenasBench, a 2.3× improvement over the best baseline On the new benchmark, it demonstrated a 3.
Paper summary: Tom: So to wrap up, this paper on Multi-Agent Coordinated Rename Refactoring introduces CoRenameAgent as a framework for handling the coordination of multiple rename refactorings. It tackles the core issues of figuring out what's related, ensuring those changes are safe, and propagating them across codebases.
Jane: The authors focused on separating these concerns into three specific agents: one to infer the scope, one to plan the execution safely, and another to replicate those changes everywhere.
Lu: What this means for the field is that it moves beyond just using a single agent for a task; it shows how specialized agents can work in tandem to solve complex, sequential problems like coordinated refactoring.
Meng: It seems like the practical value here is making the manual effort of propagating those changes much less painful by automating the tedious parts of finding and applying them safely.
Tom: The result they showed is a three point one times F1-score boost over previous methods on their new benchmark, which suggests this multi-agent approach offers a concrete performance gain for this specific task <ref:2601.00482#pg1>.
Jane: Ultimately, the paper is about how AI agents can augment human developers by taking on these complex coordination tasks while keeping the final decision-making firmly in human hands.
Conclusion: Tom: So we’ve been diving into CoRenameAgent, this multi-agent system designed to handle renaming code across huge projects.
Jane: It seems like it’s trying to solve that headache where you have a bunch of related changes, and figuring out the right order for them is a nightmare.
Tom: Exactly. The title itself points to the coordination part, but what’s actually new here is how they set up these three specialized agents—the scope finder, the execution planner, and the replicator.
Jane: That separation of tasks sounds like it's supposed to be the secret sauce for handling those big codebase problems where you can't just do everything at once.
Tom: Right. The authors are showing a real performance bump here, specifically a three point one times improvement on a new set of tests they created for recent renames.
Jane: That sounds like solid data, but what does that actually mean for the people who use these tools day-to-day?
Tom: It means when you start a refactoring process with just one change, this system can figure out the whole related scope and plan the safety checks automatically before you even have to touch your code.
Jane: So it’s moving from a manual, step-by-step guessing game to something where the AI does the heavy lifting of mapping out all those dependencies.
Tom: That's right. It’s about extending what a developer can reason about, not replacing them. The implication is that complex refactoring workflows become much more manageable for teams working on massive codebases.
Jane: It makes sense that they are focusing on that coordination because the hardest part of large-scale changes isn't writing the code, it’s making sure you don't break something else by accident down the line.
Tom: And they used a human-in-the-loop setup for training, which means developers get to guide what those agents learn about good versus bad scope inferences.
Jane: It’s smart design if you let the people who actually do the refactoring help shape how the AI learns to infer what's relevant.
Tom: It definitely gives us a better idea of how we can build these kinds of specialized systems that handle sequential, multi-step tasks in software development.
ABHIRAM BELLUR, MOHAMMED RAIHAN ULLAH, FRAOL BATOLE, MOHIT KANSARA, MASAHARU MORIMOTO, KAI ISHIKAWA, HAIFENG CHEN, YAROSLAV ZHAROV, TIMOFEY BRYKSIN, TIEN N. NGUYEN, HRIDESH RAJAN, DANNY DIG
University of Colorado Boulder · Tulane University · University of Texas at Dallas · NEC Corporation · JetBrains Research
cs.SE, cs.AI
Submitted: 2026-01-01
Updated: 2026-11-10
Comments: more experiments with generic coding agents
Code: https://github.com/gkamradt/LLMTest_
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 90/100
The gist: Multi-agent Coordinated Rename Refactoring presents CoRenameAgent, a novel multi-agent framework that automates coordinated renaming in a new refactoring workflow The primary value of AI agents in…
Key concepts
- Conceptual Realignment (T)
- This is a formal definition of a coordinated renaming process. It describes a sequence of atomic, semantics-preserving changes where the goal is to achieve a specific conceptual realignment in the code structure.
- Scope Inference
- This agent's job is to determine the full range of related files and elements that need renaming based only on an initial, partial change. It uses this initial change as a clue and refines its understanding through human feedback.
- Replication Agent
- This agent handles the challenge of safely applying changes across many files. It uses the inferred scope to discover relevant files by combining semantic search with program-slicing techniques, ensuring that related code is updated consistently.
Terminology
Summary
Multi-agent Coordinated Rename Refactoring presents CoRenameAgent, a novel multi-agent framework that automates coordinated renaming in a new refactoring workflow The primary value of AI agents in software development lies in their ability to extend the developer’s capacity for reasoning and action, not to supplant human involvement CoRenameAgent operates on the key insight that a developer’s initial refactoring is a clue to infer the scope of related refactorings This framework utilizes three individual agents—Scope Inference Agent, Planned Execution Agent, and Replication Agent—to handle the challenges of scoping, execution safety, and propagation across codebases The authors demonstrate that CoRenameAgent achieves a 3. p. 0 Multi-Agent Coordinated Rename Refactoring
ABHIRAM BELLUR, University of Colorado, USA
MOHAMMED RAIHAN ULLAH, University of Colorado, USA
FRAOL BATOLE, Tulane University, USA
MOHIT KANSARA, University of Texas at Dallas, USA
MASAHARU MORIMOTO, NEC Corporation, Japan
KAI ISHIKAWA, NEC Corporation, Japan
HAIFENG CHEN, NEC Laboratories America, USA
YAROSLAV ZHAROV, JetBrains Research, Germany
TIMOFEY BRYKSIN, JetBrains Research, Cyprus
TIEN N. NGUYEN, University of Texas at Dallas, USA
HRIDESH RAJAN, Tulane University, USA
DANNY DIG, University of Colorado, USA
The primary value of AI agents in software development lies in their ability to extend the developer’s capacity
for reasoning and action, not to supplant human involvement.Where the paper says it
Problem Formulation
The paper formally defines key terminology to ground the CoRenameAgent workflow, including Conceptual Realignment (T), Individual Rename Refactoring, and Coordinated Renaming A coordinated renaming for a conceptual realignment T is defined as a semantics-preserving, ordered atomic change sequence C = ⟨r(1), r(2),..., r(n)⟩ The formulation reveals three core technical challenges: (1) Scope inference under partial observability, (2) Transformation safety, and (3) Scalable propagation Specifically, the Scoping Challenge involves how to distil a developer’s high-level scope from the initial change and subsequent feedback
How the training signal is built
The training signal for CoRenameAgent is built through a human-in-the-loop paradigm where developers guide the agent to refine the renaming scope The workflow begins with a seed rename, which serves as a clue for the Scope Inference Agent to infer an explicit, natural-language Declared Scope This scope is then refined based on human feedback, such as go/no-go decisions from the developer The Episodic Memory stores facts about agent experiences and developer feedback to enable on-the-fly adaptation of CoRenameAgent to preferences
Where the gains come from
The gains in performance stem from the separation of concerns in the multi-agent architecture, where each agent specializes in a distinct part of the refactoring lifecycle The Scoping Challenge is addressed by treating the seed rename as a clue to infer a broad scope, and subsequent interactions refine this scope based on developer preferences The Planned Execution Agent uses this Declared Scope to find program elements and then presents them for human review before executing changes via IDE-based refactoring tools The Replication Agent overcomes the Safe Propagation Challenge by using Declared Scope-driven file discovery, combining semantic search with program-slicing to identify relevant files
Evaluation and Practical Utility
The evaluation uses two benchmarks: an established RenasBench and a new, uncontaminated Co-renameBench dataset of recent renames CoRenameAgent achieved an F1-score of 54.6% on RenasBench, a 2. p. 2 We designed a comprehensive evaluation of CoRenameAgent to corroborate, complement, and
expand research findings using multiple, complementary methods: formative study, comparative
study, replication of real-world refactorings, repository mining, ablation study, user/case study, and
questionnaire surveys. To compare with the state-of-the-art approaches [10], we first tested on the
established RenasBench [10], a benchmark containing 1349 renames across 161 co-rename sets. On
this benchmark, CoRenameAgent achieves an F1-score of 54. 3× improvement over the best
baseline.Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
A multi-agent framework called CoRenameAgent can automate coordinated renaming by decomposing it into three specialized agents: a Scope Inference Agent, a Planned Execution Agent, and a Replication Agent. This system can infer an explicit natural-language Declared Scope from an initial developer action and use it to guide project-wide search and execution.
-
The system can refine the renaming scope based on human feedback by using the Scope Inference Agent to
tighten (p) and/or (G) from human rejections
stored in episodic memory, ensuring future proposals avoid false positives. -
The Planned Execution Agent can use a ReAct-style loop to identify candidates, leveraging
few-shot exemplars constructed based on positive and negative reviews from the developer
to accurately match program elements to the Declared Scope. -
To ensure safety, the system strictly prohibits direct code editing, instead invoking
a curated set of IDE-backed refactoring tools
which are wrappers around IDE APIs that perform static analyses and check preconditions for semantic correctness. -
The Replication Agent can discover new relevant files by combining
structural reachability from edited sites (slicing/call-graph navigation) and semantic search (keywords)
to identify files linked by both data flow and architectural conventions. -
The system can adapt to developer preferences, as it
remembers developer feedback interactions adjusting the scope to their preferences,
resolving a major barrier by redefining the developer’s role from direct executor to supervisor of the agent’s work. -
The framework provides practical utility by reducing developer workload significantly, taking an average of 5 minutes compared to one hour for state-of-the-art tools, and achieving 100% correctness in renamings without compilation or semantic errors.
Abstract
The primary value of AI agents in software development lies in their ability to extend the developer's capacity for reasoning and action, not to supplant human involvement. To showcase how to use agents working in tandem with developers, we designed a novel approach for carrying out coordinated renaming. Coordinated renaming, where a single rename refactoring triggers refactorings in multiple, related identifiers, is a frequent yet challenging task. Developers must manually propagate these rename refactorings across numerous files and contexts, a process that is both tedious and highly error-prone. State-of-the-art heuristic-based approaches produce an overwhelming number of false positives, while vanilla Large Language Models (LLMs) provide incomplete suggestions due to their limited context and inability to interact with refactoring tools. This leaves developers with incomplete refactorings or burdens them with filtering too many false positives. Coordinated renaming is exactly the kind of repetitive task that agents can significantly reduce the developers' burden while keeping them in the driver's seat. We designed, implemented, and evaluated the first multi-agent framework that automates coordinated renaming. It operates on a key insight: a developer's initial refactoring is a clue to infer the scope of related refactorings. Our Scope Inference Agent first transforms this clue into an explicit, natural-language Declared Scope. The Planned Execution Agent then uses this as a strict plan to identify program elements that should undergo refactoring and safely executes the changes by invoking the IDE's own trusted refactoring APIs. Finally, the Replication Agent uses it to guide the project-wide search. We first conducted a formative study on the practice of coordinated renaming in 609K commits in 100 open-source projects and surveyed 205 developers...
Sources
- RepairAgent: An Autonomous, LLM-Based Agent for Program Repair
- Mutation-Guided LLM-based Test Generation at Meta
- Why AI Agents Still Need You: Findings from Developer-Agent Collaborations in the Wild
- RepoAgent: An LLM-Powered Open-Source Framework for Repository-level Code Documentation Generation
- Cognitive Architectures for Language Agents
- MANTRA: Enhancing Automated Method-Level Refactoring with Contextual RAG and Multi-Agent LLM Collaboration
Related papers
- ArkEval: Benchmarking and Evaluating Automated CodeRepair for ArkTS
- TestPrism: Rethinking Test Evaluation Beyond a Single Reference
- Mining Workflow Graphs for Black-Box Boundary Testing of Conversational LLM Agents
- Falsification-Based Verification of LLM-Generated Optimization Models: Sound Test Batteries and Their Detection Limits
- GitSkills: A Dataset of Agent Skills on GitHub
- For Coding Agents, the Repository Matters