💻 computer science

A Multi-Agent Consensus Protocol for Stable Software Remodularization

This paper proposes a novel multi-agent consensus protocol called Asymmetric Monotonic Concession Protocol (AMCP) that reframes software remodularization as a distributed negotiation problem to effectively balance structural cohesion and evolutionary stability, outperforming traditional optimization methods when strict stability constraints are required.

Original authors: Ahmed F. Ibrahim

Published 2026-05-07

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Ahmed F. Ibrahim

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 software system as a massive, messy library. Over time, books (code modules) get shuffled around, misplaced, or stacked in ways that don't make sense anymore. This is called "architectural erosion." To fix it, we need to reorganize the library so related books are together (high cohesion) and the shelves aren't too connected to each other (low coupling).

However, there's a catch: if you rearrange the library too drastically, the librarians (developers) get confused because they can't find their way around the new layout. They need the new arrangement to look somewhat familiar to the old one (high stability).

Traditionally, computer programs tried to solve this by finding the single "perfect" arrangement that maximizes organization, often ignoring how much it would confuse the librarians. This paper proposes a different approach: instead of a single computer trying to be perfect, it uses a negotiation between two digital agents.

The Two Agents

Think of the software as a room with two people arguing over how to arrange the furniture:

The "Cohesion Agent" (The Organizer): This agent wants the furniture grouped by function. "All the lamps should be together! All the chairs should be in a circle!" They care about how tidy and logical the room looks.
The "Stability Agent" (The Historian): This agent wants to keep the furniture exactly where it was yesterday. "Don't move the sofa! The librarians know where it is." They care about keeping things familiar.

The Negotiation: AMCP

The paper introduces a rulebook for their argument called the Asymmetric Monotonic Concession Protocol (AMCP). Here is how it works in simple terms:

The Starting Point: The room starts with the furniture exactly where it was yesterday (the previous software version).
The Proposal: The "Historian" (Stability Agent) is the only one allowed to suggest moving a single piece of furniture.
The Trade-off: The "Organizer" (Cohesion Agent) says, "If you move that lamp, the room gets 10% tidier. But if you move the sofa, the room only gets 1% tidier."
The Rule: The Historian looks at all possible moves and picks the one that gives the biggest boost to tidiness for the smallest cost to familiarity.
The Safety Net: The architect (the human in charge) sets a "Stability Budget." This is a hard limit, like a fence. The Historian can never move furniture in a way that crosses this fence. If a move would make the room too unfamiliar, it is rejected immediately.

The "Circuit Breaker"

The paper claims this system acts like a circuit breaker in an electrical panel.

If the architect says, "I don't care about stability, just make it perfect," the system behaves like a standard optimizer and rearranges everything for maximum efficiency.
But if the architect sets a strict limit ("Keep it 95% familiar"), the system acts as a safety switch. If the next best move would break that 95% rule, the system stops immediately. It doesn't force a bad move just to keep searching; it says, "We've reached the limit, and we stop here to protect the team's sanity."

The Results

The authors tested this on a real software system called Xwork (a Java framework).

Loose Rules: When they allowed the system to be flexible, the negotiation found a solution just as good as the best existing tools.
Strict Rules: When they set a strict stability limit, the system successfully refused to make moves that violated the limit, acting as a "circuit breaker" to enforce the architect's wishes.

Why This Matters

The paper argues that previous tools were "budget-blind"—they either ignored stability or tried to mix it into a single score with arbitrary math. This new method treats stability as a hard constraint that can be negotiated.

The authors proved mathematically that:

The negotiation will always finish (it won't run forever).
The agents act rationally, giving up the least amount of their own goal to gain the other's goal.
The final result is a local "best possible" compromise that respects the safety limits.

In short, this paper turns software reorganization from a "search for perfection" into a "negotiated compromise" that respects the human need for stability.

Technical Summary: A Multi-Agent Consensus Protocol for Stable Software Remodularization

Problem Statement
Current approaches to automatic software remodularization typically frame the task as a single-objective optimization problem, often maximizing structural metrics like TurboMQ to enhance cohesion and reduce coupling. While recent metaheuristics have improved search efficiency, these methods fail to address a critical pragmatic constraint: evolutionary stability. A decomposition that maximizes structural quality but differs significantly from the previous system version imposes a heavy cognitive burden on developers. Existing tools are "budget-blind," either ignoring stability or merging it into a fixed weighted sum with arbitrary coefficients, thereby lacking the ability to enforce strict stability constraints or adapt to specific stakeholder preferences.

Methodology: Asymmetric Monotonic Concession Protocol (AMCP)
The authors reframe software modularization not as a static optimization problem, but as a distributed consensus problem among autonomous agents. The proposed framework introduces two agents with conflicting utility functions:

Cohesion Agent ( $A_{coh}$ ): Strives to maximize structural density using a normalized TurboMQ metric.
Stability Agent ( $A_{sta}$ ): Seeks to preserve the layout of the previous version ( $D_{prev}$ ) by minimizing the Move-plus-Join (MoJo) distance.

The core mechanism is the Asymmetric Monotonic Concession Protocol (AMCP). In this protocol:

Asymmetry: The Stability Agent acts as the sole proposer, reflecting the real-world maintenance scenario where the legacy architecture is the default state. The Cohesion Agent implicitly accepts moves that improve cohesion without violating the stability floor.
Concession Logic: The Stability Agent evaluates potential single-module reassignments and selects the move that minimizes the Concession Ratio ( $R(\delta)$ ). This ratio represents the cost in stability utility per unit of gain in cohesion utility.
Thresholds: The protocol enforces explicit survival thresholds ( $\tau_{sta}$ and $\tau_{coh}$ ). If a move violates the stability budget ( $\tau_{sta}$ ), it is rejected.
Termination: The negotiation terminates when no valid move exists that improves cohesion while respecting the stability threshold, or when the set of valid moves is exhausted.

Key Contributions

Formal Mathematical Model: The paper establishes a formal model of software remodularization as a distributed consensus problem among utility-driven agents.
The AMCP Protocol: The authors propose the AMCP, which includes formal proofs for:
- Finite Termination: The protocol is guaranteed to terminate in a finite number of steps (bounded by $n \cdot (k_{max} - 1)$ ), as it uses Cohesion Utility as a strict Lyapunov function.
- Rationality (Zeuthen Strategy): The protocol's behavior maps to the Zeuthen Strategy, ensuring agents make minimal concessions necessary to satisfy the opponent, prioritizing "cheap" concessions first.
- Local Pareto-Satisfactoriness: The resulting partition is locally Pareto-satisfactory within the single-move neighborhood, meaning no single reassignment can strictly improve cohesion without violating the stability threshold.
Complexity Analysis: The approach prunes the search space effectively, evaluating $O(n \cdot k)$ candidates per step, contrasting with the exponential state space of population-based metaheuristics.

Experimental Results
Preliminary experiments were conducted on a synthetic benchmark and the Xwork Java framework (113 classes, 10 packages).

Budget Enforcement: The protocol successfully enforced strict stability budgets. When the stability threshold ( $\tau_{sta}$ ) was set to a binding constraint (0.95), the protocol truncated the search early (3 steps), preserving a stability utility of 0.9583, significantly higher than the unconstrained Bunch optimizer (0.9167).
Loose Budgets: For looser budgets ( $\tau_{sta} \leq 0.90$ ), the results were identical to the unconstrained case, indicating that the protocol naturally exhausts all structural improvements before stability becomes a limiting factor.
Comparison: The negotiated consensus matched state-of-the-art optimizers (Bunch, CC/G) when stability constraints were loose but acted as a "circuit breaker" when strict constraints were applied.
Efficiency: A Python implementation averaged 1.24 seconds per step on the Xwork system, confirming the tractability of the approach.

Significance and Claims
The paper claims a qualitative leap forward by replacing static, one-shot fusion of clustering outputs with a dynamic, multi-agent negotiation.

Architectural Control: The primary significance lies in the ability to mathematically enforce a "stability budget" set by the architect, ensuring the system layout does not degrade merely for the sake of structural optimization.
Formal Guarantees: Unlike heuristic approaches, this framework provides formal guarantees regarding termination and rational concession behavior.
Scope: The authors note that while preliminary results are promising, a more extensive empirical evaluation covering ten additional systems and comparisons with multi-objective evolutionary algorithms (e.g., NSGA-II) is deferred to a forthcoming full paper. The current work serves as a proof of concept for the negotiation paradigm at the code level.