multi-repo-agentic.md

Moderne: The Platform for Multi-Repository Agentic Workflows

The Problem

AI coding agents are powerful but fundamentally single-repository tools. When an organization needs to make changes across dozens, hundreds, or thousands of repositories—whether migrating frameworks, fixing vulnerabilities, or enforcing standards—they face a gap:

Agents can edit code. But who orchestrates the fleet?

Moderne's Unique Value

Moderne provides the infrastructure layer that turns single-repo agent capabilities into organization-scale transformation:

1. Organization Mapping

Repositories aren't just a flat list. They're grouped by business unit, tech stack, or custom segmentation. When you say "update all Spring Boot 2.x services in the payments domain," Moderne knows exactly which 47 repositories that means—and which 200 it doesn't.

2. Safe Multi-Repository SCM Operations

Mass commits and PRs sound simple until you try them:

• Rate limiting — GitHub/GitLab/Bitbucket will throttle you. Moderne manages the queue.
• Branch divergence — Target branches move. Moderne handles rebasing automatically.
• VCS heterogeneity — One org, three SCM backends. Moderne abstracts them.

3. Multi-Repository PR Tracking

To your VCS, PRs are isolated. To your organization, they're a coordinated change. Moderne tracks them as a unit—showing completion percentage, identifying blockers, enabling batch merge when ready.

The Changeset Workflow

flowchart TB
    subgraph Moderne["Moderne tracks the chain"]
        direction TB
        Start["Recipe Run / Batch Change"]
        C0["Changeset C₀"]
        Local1["Local working copies + patches"]
        Applied["Patches applied locally"]
        Agent["Agent verification & editing"]
        C1["Changeset C₁ (parent: C₀)"]
        Cn["Changeset Cₙ"]
        PRs["PRs opened, tracked as a unit"]

        Start --> C0
        C0 -->|"mod git sync --changeset=C₀ --with-sources"| Local1
        Local1 -->|"mod git apply --last-recipe-run"| Applied
        Applied --> Agent
        Agent -->|"Push to Moderne"| C1
        C1 -.->|"Repeat"| Cn
        Cn -->|"Mass commit/PR via Moderne"| PRs
    end

Loading

Throughout this chain, Moderne tracks the lineage—each changeset knows its parent.

Unified Domain Model: OrganizationChangeset

Whether changes originate from an OpenRewrite recipe run or a batch change pushed by an agent, they share the same domain model: OrganizationChangeset.

This means:

• The diff viewer works the same — Browse file changes across hundreds of repositories, regardless of whether a recipe or an agent produced them.
• The commit UI works the same — Select repositories, customize commit messages, open PRs—all from the same interface.
• The PR tracking works the same — Monitor merge status, handle conflicts, batch merge when ready.

The Moderne UI is invariant to what produced the changeset. A recipe run, an agent refinement, or a human batch change all flow through the same visualization, review, and commit pipeline.

flowchart TB
    subgraph UI["Moderne UI"]
        Diff["Diff Viewer"]
        Commit["Commit UI"]
        Tracker["PR Tracker"]
    end

    subgraph Abstraction["Shared Abstraction"]
        OC["OrganizationChangeset"]
    end

    subgraph Sources["Change Sources"]
        Recipe["Recipe Run (C₀)"]
        Batch["Batch Change (C₁)"]
        Future["Future Sources"]
    end

    Diff --> OC
    Commit --> OC
    Tracker --> OC

    Recipe --> OC
    Batch --> OC
    Future --> OC

Loading

When you're ready to commit, you point Moderne at the last changeset in the chain—the most refined version. Moderne doesn't care that C₀ came from OpenRewrite and C₁ came from Claude. It sees one unified set of changes ready for mass commit.

Why This Matters

OpenRewrite gets you 80% of the way on automated migrations. Agents can handle the remaining 20%—the custom logic, the edge cases, the verification. But without Moderne:

• You're scripting git clones and pushes yourself
• You're managing rate limits yourself
• You're tracking 500 PRs in a spreadsheet
• You're rebasing manually when main moves

Moderne is the control plane for multi-repository change—whether that change comes from a recipe, an agent, or a human.