EvoGit: Decentralized Code Evolution via Git-Based Multi-Agent Collaboration

Abstract: We introduce EvoGit, a decentralized multi-agent framework for collaborative software development driven by autonomous code evolution. EvoGit deploys a population of independent coding agents, each proposing edits to a shared codebase without centralized coordination, explicit message passing, or shared memory. Instead, all coordination emerges through a Git-based phylogenetic graph that tracks the full version lineage and enables agents to asynchronously read from and write to the evolving code repository. This graph-based structure supports fine-grained branching, implicit concurrency, and scalable agent interaction while preserving a consistent historical record. Human involvement is minimal but strategic: users define high-level goals, periodically review the graph, and provide lightweight feedback to promote promising directions or prune unproductive ones. Experiments demonstrate EvoGit's ability to autonomously produce functional and modular software artifacts across two real-world tasks: (1) building a web application from scratch using modern frameworks, and (2) constructing a meta-level system that evolves its own language-model-guided solver for the bin-packing optimization problem. Our results underscore EvoGit's potential to establish a new paradigm for decentralized, automated, and continual software development. EvoGit is open-sourced at https://github.com/BillHuang2001/evogit.

• The paper introduces EvoGit, a decentralized framework that employs a Git-based phylogenetic graph to autonomously evolve code.
• It details innovative methods like mutation and three-way crossover, validated on tasks such as web application development and meta-level code synthesis.
• The architecture leverages autonomous agents with strategic human oversight to enhance scalability, traceability, and reproducibility in software development.

EvoGit: Decentralized Code Evolution via Git-Based Multi-Agent Collaboration

Introduction

"EvoGit" (2506.02049) presents a novel framework for decentralized software development, leveraging multi-agent collaboration to autonomously evolve code over a Git-based structure. Unlike traditional development paradigms that rely on scalar reward functions or dense human feedback, EvoGit operates asynchronously without centralized coordination or shared memory. This essay explores EvoGit's architecture, methodology, and its experimental validation across complex real-world tasks.

Methodology

EvoGit's decentralized framework facilitates collaborative software development through a phylogenetic graph, using Git for version control. This graph captures the entire code evolution history, allowing agents to propose, mutate, and crossover code versions without a central orchestrator.

Core Components

1. Autonomous Agents: Agents operate independently, navigating the code version space by proposing mutations or crossovers. This decentralized operation relies on a directed acyclic graph (DAG) rooted in an initial version, enabling multiple developmental trajectories.
2. Human Product Manager: Oversees the development by defining design intents and providing feedback selectively, ensuring the process aligns with high-level goals.
3. Phylogenetic Graph: Serves as the backbone for evolutionary development, encoding a complete lineage of code versions and supporting traceability, reproducibility, and rollback capabilities.
4. Git Integration: Provides a compatible infrastructure for version control, enabling scalability and distributed development.

Code Evolution Operations

EvoGit applies evolutionary mechanisms like mutation and crossover within the phylogenetic graph:

• Mutation: Agents propose incremental changes to code, evaluated without scalar optimization metrics. These are locally compared to parent versions, ensuring each change enhances functionality.

  Figure 1: Illustration of the mutation and three-way crossover operations in EvoGit. (a) Mutation with localized changes. (b) Three-way crossover combining changes from divergent branches.

• Three-Way Crossover: Merges changes from separate branches using a common ancestor, preserving semantic context and enabling structural recombination without conflicting changes.

  Figure 2: Partial order preceq over code versions, illustrating branching and merging scenarios in EvoGit.

Experiments

EvoGit was validated on two tasks demonstrating its capability for decentralized code evolution:

Task 1: Web Application Development

EvoGit autonomously developed a modern web application, showcasing its ability to construct complex user interfaces without human-driven templates or visual feedback.

Figure 3: Early stage of the web application development, illustrating code evolution from an initial scaffold.

Task 2: Meta-Level Code Synthesis

EvoGit demonstrated recursive development by evolving a pipeline for automated algorithm design, constructing a solver for the bin-packing problem with an LLM in the loop.

Figure 4: Schematic of meta-level code synthesis (Task 2), using EvoGit for evolving a bin-packing solver.

Implementation Considerations

Implementing EvoGit involves integration with popular build systems and static analysis tools to collect metadata for evaluating version improvements. The use of Git ensures compatibility with existing development workflows, allowing seamless adoption. Key considerations include:

• Decentralization: Agents operate independently, using the phylogenetic graph for coordination, enabling scalability in large teams.
• Feedback Mechanism: EvoGit relies on structural transformations rather than traditional reward functions, simplifying the evaluation process.
• Human Oversight: Human involvement is strategic, providing high-level guidance without micromanaging the development process.

Conclusion

EvoGit offers a robust framework for decentralized software evolution, leveraging autonomous agents and a Git-based phylogenetic graph to collaboratively explore code version spaces. By eliminating centralized constraints and embracing a structural approach to evolution, EvoGit facilitates scalable code development, applicable to various domains requiring complex adaptive solutions. Future advancements could include automated divergence handling, adaptive pruning strategies, and enhanced integration with state-of-the-art LLMs for more intelligent agent behavior.