Winner of the Multi-Agent Track at the AgentX Competition (Agentic AI Summit).

🎬 EvoGit Animation (click to hide)

1. 🚀 Overview
2. ✨ Key Features
3. 📦 Live Demos
4. 🧬 How to Explore the Results
5. 📚 Paper

EvoGit is a decentralized multi-agent framework that reimagines software development as a collaborative, evolutionary process. It deploys a population of independent coding agents that evolve a shared codebase asynchronously, without centralized coordination, explicit message passing, or shared memory.

All coordination emerges implicitly through a Git-based phylogenetic graph that tracks the complete version lineage. This graph allows agents to read from and write to the repository, enabling scalable parallel exploration while preserving a consistent, auditable history of every change.

For detailed methodology and experimental results, refer to our paper.

• 🧠 Decentralized Coordination: Agents operate independently and coordinate organically through the shared version graph. This resembles stigmergy in biological systems, where interactions are indirect and mediated by the environment.
• ⚙️ Git-Native Evolution: The entire framework is built on Git. Evolutionary concepts map directly to Git primitives, making the process inherently compatible with standard developer tools.
• 🌿 Traceable & Auditable Lineage: Every edit, merge, and decision is recorded as an immutable Git commit. This provides full transparency and reproducibility of the entire development process.
• 🤝 Sparse Human Oversight: The human's role shifts from a coder to a high-level Product Manager. You define initial goals and provide periodic, lightweight feedback to prune unproductive branches and promote promising ones.

Explore how EvoGit enables collaborative AI development across two real-world projects. For more details, please visit the respective GitHub repositories and inspect the Git history to see how multiple agents evolved the code.

A multi-agent AI system collaboratively builds a complete one-page interactive website—from layout and UI to animations and dark mode. The project was initialized by a human product manager and guided with ~10 feedback interventions.

AI agents iteratively evolve a meta-level algorithm designer, which itself generates and refines a solver for the classic Bin Packing Problem. This creates a two-layer pipeline: EvoGit → Auto Algorithm Designer → Bin Packing Solver A human manager provided an initial setup and ~5 rounds of feedback throughout the optimization process.

def bin_packing_solver(items: list[float], budget: int) -> list[int]:
    import time

    if not items or not all(0 <= w <= 1 for w in items):
        return []

    start_time = time.time()

    items_sorted = sorted(enumerate(items), key=lambda x: x[1], reverse=True)
    bins = []
    bin_indices = [-1] * len(items)

    for index, weight in items_sorted:
        placed = False
        for bin_index, bin_weight in enumerate(bins):
            if bin_weight + weight <= 1:
                bins[bin_index] += weight
                bin_indices[index] = bin_index
                placed = True
                break
        if not placed:
            bins.append(weight)
            bin_indices[index] = len(bins) - 1

    best_solution = bin_indices[:]
    best_bin_count = len(bins)

    def refine_solution():
        nonlocal best_solution, best_bin_count
        for _ in range(100):  # attempt refinement a number of times
            new_bins = []
            new_bin_indices = [-1] * len(items)
            new_solution = []
            for i in range(len(items)):
                weight = items[i]
                placed = False
                for bi in range(len(new_bins)):
                    if new_bins[bi] + weight <= 1:
                        new_bins[bi] += weight
                        new_bin_indices[i] = bi
                        placed = True
                        break
                if not placed:
                    new_bins.append(weight)
                    new_bin_indices[i] = len(new_bins) - 1
            new_bin_count = len(new_bins)

            if new_bin_count < best_bin_count:
                best_solution = new_bin_indices
                best_bin_count = new_bin_count

            if (time.time() - start_time) * 1000 > budget:
                break

    refine_solution()

    return best_solution

EvoGit uses Git not only as a version control tool, but also as a transparent window into the code evolution process. Here's how to inspect our demos:

1. 🧑‍💻 The human-initialized seed lives in the main branch.
2. 🤖 AI-generated code lives in branches named: host<i>-individual-<j>, where i = host node index, j = agent index.
3. 🔍 Each agent branch contains an independent development trajectory. You can explore these using GitHub’s commit history or local Git tools.
4. 📈 Git diffs and logs reveal the precise changes made in each commit.
5. 🧭 Use git log --graph or GitHub’s branch visualization (under Insights -> Network) to see how code diverged and converged over time.

All changes are versioned and traceable. Every commit represents an autonomous decision by an agent—captured, auditable, and reproducible through Git.

Read the full framework design, evaluation methodology, and results in our paper:

• ArXiv:2506.02049