Mergerie makes what an agent does usable by a team.
Scored reviews, coding and AI agents on your machine, with the claude or copilot CLI you already pay for, for GitLab and GitHub. The AI scores, fixes and converges. You merge.
Try it in 30 seconds
npx mergerie demoNo token, no account: a demo with fictional data.
★ See the code on GitHub Read the guide
- AGPL-3.0, open source
- GitLab and GitHub
- Claude, Copilot, Codex or Gemini
- No API key
- Zero telemetry
Local.
A Node + SQLite server on your machine. The only network calls are the ones you configure: your forge, your Jira.
Your subscription.
Mergerie drives the claude or copilot CLI you already have, both proven; codex and gemini are written from their documentation. No Mergerie bill: each pass draws on the quota of your own plan.
You merge.
The AI scores, explains, fixes, converges. Publishing and merging stay your clicks. So does pushing, unless you turn on the convergence loop, within the thresholds you set.
Day to day
What it changes for you
- “I don't reread the whole MR after every fix.”The re-review only covers what changed since the previous version of the report.
- “I know what is new, what is lingering and what is really resolved.”Every finding is tracked from version to version, and resolved means gone from the diff.
- “Three weeks later, I can find out why we decided that.”Reviews, their versions and the questions asked are kept, and “by Claire” is read from git.
- “I adopt the tool without forcing a new SaaS on the team.”Everything runs on each machine with the CLI already paid for; sharing goes through a git repository the team owns.
Reviews
What a review looks like
A merge request lands in your queue. One click: the AI reads the diff, not the whole repository, and returns a structured report. Findings ranked blocking / important / minor, each pointing at a file and a line. A score out of 10, calibrated on named anchors. What is good, and a merge checklist. Is the subject new to you? Ask for a plain-language explanation. Your own remarks anchor on the line they are about, stay pending while you finish reading, then go out to the merge request in one go.
- Scored, versioned reviews; re-review is incremental: only what changed since
- Findings tracked to resolution, with a git guard: resolved means gone from the diff
- Team rules that fire on a path (
**/migrations/**) and badge the MR before the review - Per-MR context: the domain rule, last year's incident, a screenshot. Sent with the diff, kept for the next review
- A question on a finding gets an answer under the report, without regenerating it. The score and the versions do not move
- Publish the report on the merge request, or only its link when the team shares a data repository: three lines, with how many findings are blocking, instead of six hundred lines
- The verdict the forge reads itself: Approve from the report, Resolve on each discussion thread, and the forge's own CI (pipeline, checks) as a badge on every merge request in your queue. Never a burst of inline comments
- Repository groups: twenty micro-services share the same rules, verifiers, prompt templates and instructions. They carry them once, on a group that travels with the team
Convergence
Review → fix → re-review, until it passes
The autonomous loop reviews, lets the AI fix what it found, commits, pushes, then reviews again. It stops at the score threshold you set, or at the maximum number of rounds. When the AI cannot settle a decision, it asks you instead of guessing: the loop goes on hold, you get a notification, you answer, then you start Converge again and it resumes the same session. After each pass, the merge request's verifier runs and its verdict shows on the panel. It is information beside the score, never an exit condition: green tests do not mean the change is right.
- ReviewScore and findings on the diff.
- FixThe agent corrects, commits and pushes on the same branch.
- Re-reviewOnly what changed. Stop at the threshold.
A verdict that isn't an opinion
A verifier is a plain list of commands attached to a merge request (npm ci, npm test). It gives the merge request an objective verdict: ✓ verified, ✗ 2 tests broken, ⚠ base already red. Broken test names are read straight from TAP or JUnit output. Merge requests from several repositories that only hold together as a set are verified together. The verifier's commands run on your machine. The form suggests exact lines from what the clone declares (npm, pnpm, yarn, composer, Makefile, pytest, Go, Rust, Maven, Gradle, .NET), and their docker compose run --rm variant when a compose file is there.
Agents
An AI that knows your twenty repositories, not only the one you are in
A session started inside a clone already has the code, its CLAUDE.md and its skills. What it does not have, Mergerie does: the nineteen other clones, what was merged this morning, and the knowledge that lives between repositories. An agent is a session profile: a role, a scope of repositories, tools, skills, an output, sometimes a schedule. A run is an ordinary session: same follow-ups, same questions, same archived passes, same cost. Three rules hold everywhere. An agent never pushes and never publishes on its own. It never guesses a repository. It never handles conversations between humans.
- “Where do we handle notifications, here?”A domain agent searches the repositories you ticked, and only those. Then it writes the map: entry points, mechanisms, types, configuration, tests, pitfalls. Every path it quotes is opened inside the clone; one that does not exist is marked (unverified) and counted.
- Then ask it, or code with itThe map becomes the context: ask the agent a question, or open a coding session with its repositories already ticked. If it finds a mistake in its own map, it reports it instead of quietly patching it.
- An incident, down to the lineThe built-in investigator takes a stack trace, a log or a ticket excerpt, and searches every clone. It names the repository, the file and the likely cause. If it finds nothing, it says so, rather than offering a plausible repository.
You know when a map has aged, with no AI call
The knowledge records each repository's SHA and the paths it quotes. Mergerie counts the commits that touched those paths since, 7 commits since the map, with no AI call. One click lists them with their date, author and message. Update relaunches the cartographer with the previous map, the gaps it reported and those commits. The result waits for you with a readable diff, and the agent keeps working from the old map until you validate. Agents also run on a schedule if you want, every day, week or month, and the morning brief says what ran during the night.
Team
Share the work. Keep the secrets.
Point Mergerie at a git repository, your team's own on the forge you already have, and the accumulated work lives there, one readable file per object. Everyone keeps their instance, their tokens and their AI subscription: requests leave their machine, it is the result that is shared. No server, no account, nothing to administer: the forge already has permissions, backups and a history.
Goes to the team
- Review rules, verifiers and repository groups
- Agents and their map of the code
- Reviews, every version, every finding
- The review state of each merge request
- Team settings and prompt templates
- The notes pages, sessions and todos you tick
Stays on this machine
- API tokens, the clone folder, absolute paths
- Which repositories you follow: each machine keeps its own list
- Sessions, questions and todos, until you tick them
- Drafts, always: an unsent remark, a follow-up still being typed
- What each AI pass cost you
- The Git and Jira tabs
- Private by default, shared by choiceA session is how you worked: the prompt as you typed it, the three retries, the screenshot that shows another window. It carries a Share checkbox, unticked. Its passes and attachments follow it: it cannot be half shared. Untick it, and the whole folder leaves the repository.
- Told what leaves, before it leavesAttaching opens a summary first: what goes, what stays, and file by file how many will be added, changed or deleted. Deleted: none. Sending writes, it never erases. And a sync that would remove more than half of what the repository holds (and at least ten documents) is refused, not applied: Clone / attach then rewrites what is missing.
Start a team in three steps Sharing with a team, in the guide →
And the rest
Reasons to stay, once you are in
- Coding sessions from a ticketStart from a Jira ticket: the session dialog lists yours as you type. The branch, the prompt and the commit message arrive pre-filled. The AI codes, commits, pushes, opens the MR.
- A technical brief per ticketDescribe a Jira ticket for the AI, tick the repositories and the branch of each: the code often lives on a release branch. The Analysed tab lists every ticket already briefed, and My tickets can be filtered on it.
- Plan first, then approveTick Plan first: the first pass reads and returns a plan: files, steps, risks. You read it on the card, add a remark, and Approve and code resumes the same agent session to carry it out. While a session runs, Stop and resume with this instruction steers it without losing its thread.
- Multi-repository sessionsOne prompt, five repositories, five merge requests created together, and verified together. Other repositories can be linked read-only: the AI reads their API and schema to code correctly, and cannot touch them.
- Sessions that stay, or waitFind a session from three days ago by its prompt and send a one-sentence follow-up: the agent resumes its session. Or schedule a session, or a follow-up, for a date and time: your workstation launches it, and catches up if it was off.
- Git, with conflicts on screenBranch merges with side-by-side conflict resolution and a full-screen view. One button asks the AI for a resolution of every conflict at once, each with its reason, each validated by you. On a merge request in conflict or behind its target, Update with the AI opens a pre-filled session that rebases without pushing: you read the diff, then push with
--force-with-lease. - Security you can readA secure mode, one click, asked once at start-up. Reviews and explorations run the agent read-only; coding sessions run in the CLI's sandbox once Test the sandbox has proven it on your machine, on an allowlist otherwise. Without it, the agent has exactly the rights of your CLI, as in your terminal. Either way, a verifier or an agent received from the team waits for your approval, and exposing the server on the network requires a token.
- Plugins, since 3.0A folder with a
plugin.jsonand anindex.js, declared permissions, a closed context: settings, prefixed tables, routes, events, a tab, a section of the brief. Jenkins, Docker and Links became plugins in their own repositories. Settings → Plugins installs from a git address, enables without a restart, updates in one click. An SDK (@mergerie/plugin-sdk) gives the types and a generator. - Several agent binaries, one defaultSettings → AI sessions lists your binaries: the default for reviews and convergence, others to pick per session. Each carries its arguments and environment variables, passed to the agent alone, never to your terminal. A Claude Code wired to a local Ollama next to your subscription: your code does not leave.
- Notes your agents keep up to dateA documentation agent writes the general page and decides itself how many sub-pages the detail needs. They are matched by title from one run to the next, so a weekly agent updates them instead of piling up copies.
- A morning brief, not a dashboardWhat the night's agents produced, the merge requests ready to merge, the sessions stopped on a question, the remarks you wrote and never sent.
Install
Try it, then plug it in
- The demo, no token
Fictional data, dry-run AI, a fictitious team of three. Explore every screen.
npx mergerie demo - The real thing, once the CLI is connected
With the CLI from the step below installed and logged in, start Mergerie, then Settings → your GitLab or GitHub token, and the folder where clones go.
npx mergerie
Mergerie drives the claude CLI through your existing subscription. Claude Code docs.
npm install -g @anthropic-ai/claude-code && claudeMergerie drives the copilot CLI through your existing subscription. Copilot docs.
npm install -g @github/copilot && copilotRequires Node 22.9+ and git. macOS, Linux, Windows (WSL). The first launch writes a short .env in ~/.mergerie, pointed at the agent it finds. The agent, its arguments and its timeout are then set on screen, without restarting. Claude Code and Copilot CLI are proven; Codex CLI and Gemini CLI are written from their documentation and marked “unverified” in Settings → AI sessions, where the backend is chosen.
Compare
Why not a hosted reviewer?
Other tools produce a review. Mergerie keeps the path between the review, the fix and the merge decision. Hosted reviewers are good. But they read your code on their servers and bill per seat. Mergerie runs on your machine, for GitLab as for GitHub, on the AI plan you already pay for, and keeps that path end to end. And your team's knowledge lives in a git repository you own.
| Criterion | Mergerie | CodeRabbit | Copilot code review | GitLab Duo |
|---|---|---|---|---|
| Runs on your machine | ✓ yes | ✗ no | ✗ no | ✗ no |
| GitLab support | ✓ yes | ✓ yes | ✗ no | ✓ yes |
| Extra cost per seat | no Mergerie bill; each pass draws on the quota of your Claude / Copilot / Codex / Gemini plan | per seat | per seat | per seat |
| Convergence loop (review → fix → re-review) | ✓ yes | ✗ no | ✗ no | ✗ no |
| Team knowledge as files in a git repository you own, no server | ✓ yes | ✗ no | ✗ no | ✗ no |
FAQ
What people ask before installing
Does my code go through Mergerie's servers?
No. There is no Mergerie server. Mergerie runs on your machine and talks only to your forge (GitLab or GitHub) and to the AI CLI you configured, under that provider's own terms. And if your code must not leave at all, Settings → AI sessions accepts several agent binaries: a Claude Code wired to a local Ollama, next to your subscription. See what leaves your machine.
Do I need to pay for a Mergerie subscription?
No. The open-source edition needs no Mergerie subscription. You need your own forge access, and an already-installed, already-paid Claude Code, Copilot, Codex or Gemini CLI, billed by that provider.
What does a review cost, concretely?
No Mergerie bill. Each pass draws on the quota of the plan you drive: Claude Code's usage limits, Copilot's premium requests. The report itself says what it cost in tokens, and the Stats tab gives the average cost per reviewed merge request and the most expensive reviews. That cost stays on your machine: it does not go to the team repository, except as a daily total if you tick the box.
Which AI CLI can it drive?
Claude Code and GitHub Copilot CLI, proven. OpenAI Codex CLI and Gemini CLI are written from their documentation, without the maintainer having tried them, and Settings say “unverified”. The backend is detected from the binary you point it at. Each is wired with the guarantee it can prove: read-only reviews, a sandbox for coding sessions. An unknown CLI still runs, at a reduced level that the journal states on its first line.
Does Mergerie work with GitLab?
Yes, GitLab and GitHub side by side, repository by repository. See the sourced comparison.
Self-hosted GitLab, corporate proxy, internal CA?
Yes. A GitLab or GitHub Enterprise instance behind an internal certificate authority is declared with GITLAB_CA_CERT or GITHUB_CA_CERT (the full chain up to the root); GITLAB_INSECURE_TLS=1 exists for troubleshooting, and GIT_CLONE_SSH=1 clones with your SSH key. Your shell's proxy variables are passed to the agent, whose environment is an allowlist. See the guide section.
Can the AI push or merge on its own?
Not by default. Push, publish and merge stay separate, explicit actions. Once you turn it on, the autonomous convergence loop can commit and push on its own, with the thresholds you set. Publishing and merging remain yours.
Does Mergerie replace my CI?
No. It runs your own test commands and shows their verdict on the merge request. It replaces neither your CI pipelines nor your branch protection rules.
Is Jira required?
No. Reviews, convergence, verifiers, agents and team sharing do not need it. Jira serves the features that start from a ticket: the coding session from a ticket, the technical brief, the Jira tab with your tickets, and keys like PROJ-720 turning into links. Settings → Jira: URL, email, API token.
What about Windows?
Mergerie runs through WSL. Paths, credentials and performance follow WSL's rules, not native Windows.
What does the AGPL commit me to, in a company?
Nothing beyond use. You install Mergerie on your team's machines and use it internally: nothing to publish. You modify it and keep the change on your machines: nothing either. The obligation to provide your source code under the AGPL only applies if you redistribute your modified version, or make it available to users over a network, as a SaaS. See LICENSE.
One maintainer: what if he stops?
The code is AGPL and forkable: it stays with you as is, and you can keep it alive under another name. Your data is readable files, JSON and Markdown, in a git repository you own, plus a SQLite database on each machine. No Mergerie server goes dark, no account gets closed.
Who maintains Mergerie, and can I contribute?
One maintainer and one rights holder, on purpose: the licence and the responsibility for the code stay clear. Outside pull requests are closed, and patches pasted in an issue are not merged either. Bug reports and ideas, described in words, are welcome as issues: the fix is then written from scratch. Forking is allowed, keeping the licence and under another name. See CONTRIBUTING.md.
Teams
Your team, on your forge, today.
Need more than a shared repository: a server on your infrastructure, SSO, an audit trail, or a one-day setup? Write to me: an email, three lines.