GitWarren
GitWarren's MCP server lets an agent track local git repositories, open pull-request-style reviews of branches or uncommitted work, and converse in review comment threads — all on the user's own machine.
Manage tracked repositories: list them with live git state, fetch one, add, rename/repoint, or remove.
Manage reviews: list filtered by repository and open/closed status, fetch one (with its repository path for direct git inspection), create reviews comparing two refs from their merge base, update title/description/refs/status, or delete one.
Review uncommitted work: a review's head branch worktree contributes staged, unstaged and untracked changes; passing the same ref twice reviews only uncommitted work.
Read discussion: list every review-level and line-level thread with full message history, authorship, current anchors (anchored/moved/outdated), anchor snapshots, and resolved image attachments as real file paths.
Write discussion: start review-level or line comments (with base/head side, multi-line ranges, and markdown screenshots copied into GitWarren), reply in threads, resolve or reopen threads, and edit or delete its own messages.
Declare attribution: report and set a session label via agent_identity, since the tool name comes from the MCP handshake.
Hand back links: results carry guiUrl (and webUrl on a tailnet) that open the review in GitWarren for the user to click.
Provides tools for reviewing local git repositories, including browsing diffs, comparing branches, and managing review conversations.
GitWarren
Code review for your own git repositories, on your own machines. Your machines, your agents, no one else's server — and no account.
Built for the moment a coding agent — Claude Code, Codex, or anything else that edits files on your disk — has just finished, and its work is sitting in your worktree uncommitted. Read that diff here, on your own machine, before it becomes a commit.
gitwarren.com has downloads for macOS, Windows and Linux.
What it does
Tell GitWarren which local git repositories you care about, then open reviews against them — a review is a comparison of two refs, presented the way a pull request is, with conversation, commits and files changed tabs, and a browse files tab for the code the change did not touch.
Review work before it is a commit. If the branch you are reviewing is checked out in a worktree, GitWarren finds that worktree — wherever it is — and folds its staged, unstaged and untracked changes into the diff. That is exactly when review is most useful, and it is the part that makes this worth having.
Prose as well as code. Diffs read unified or side by side, with the changed words picked out of a changed line. A Markdown file can be read rendered, with its edits marked like tracked changes, and commented on paragraph by paragraph.
Nothing is cached. Every branch name, commit and diff on screen is read from git at the moment it is shown.
Nothing leaves your machine. Reviews live in one SQLite file in your application-data directory. No account, no telemetry; the desktop app's one outbound request is the update check.
Agents are first-class. Local AI agents get the same capabilities through an MCP server over stdio — they open reviews, read your comments, reply in a thread and resolve what they fixed.
Desktop app or browser. It runs as an Electron app on macOS, Windows and Linux, or as a command that serves the same review UI into a browser tab. Same renderer either way; the shell is the only thing that differs.
Your other machines too. A machine with no screen at all — a VPS, a WSL distro, a box an agent works on — runs the headless half and is reviewed from somewhere else, over SSH, over
wsl.exe, or over your own tailnet, and its repositories are listed on the same home screen as this machine's. Reviews live on the machine the code is on and stay there; nothing is replicated or relayed anywhere but the computers you already own.
Comments go on the line, the way a pull request does them. The agent that wrote the code answers in the same thread, while you are still reading the diff:
Related MCP server: git-mcp-server
Install
The desktop app
Download it from gitwarren.com, or on macOS:
brew install --cask klarluft/tap/gitwarrenThe command line
Serves the same review UI in a browser instead of an Electron window — for a machine that will not have the app on it, or one with no screen at all:
brew install klarluft/tap/gitwarren-cli # macOS and Linux, brings its own Node
curl -fsSL https://gitwarren.com/install.sh | sh # macOS and Linux, no Homebrew needed
npx gitwarren serve # anywhere Node 22.14+ is, including WindowsThen gitwarren serve --open. See
The gitwarren command line.
Into a coding agent
If you arrive from a coding agent, start here instead. The plugin brings the MCP server and a note that teaches the agent when to open a review and how to answer your comments:
/plugin marketplace add klarluft/gitwarren-app # Claude Code, then:
/plugin install gitwarren@gitwarren
gemini extensions install https://github.com/klarluft/gitwarren-app
npx skills add klarluft/gitwarren-app # the note alone, for any agentCursor, Codex, VS Code and Kiro read the same repository from their plugin screens. See Installing it as a plugin.
Documentation
Guide | What is in it |
What a review is, how uncommitted work is found, reading and navigating a large diff, side by side and wrapped lines, Markdown previews, browsing and searching the repository, marking files reviewed, opening a file in your editor, keyboard shortcuts | |
The MCP tools, installing the plugin, how an agent links you back into the app, comment threads, images | |
| |
Reaching a repository over SSH, over | |
The stack, the shared service layer both surfaces call, and what is and is not stored | |
Running from source, the project layout, database migrations | |
Cutting a release, auto-update, code signing and notarization | |
The fields Glama's admin page actually reads, and why they say what they say | |
What GitWarren does not do, and why | |
The design plan behind the remote-host model |
Agents setting GitWarren up on a user's machine should read llms-install.md.
Contributing
Contributions are welcome. Anything larger than a bug fix starts as a discussion in Ideas, so the shape can be agreed before you spend time on it; once it is settled it becomes an issue. See CONTRIBUTING.md for the development workflow, the two design constraints that changes need to respect, and what a good pull request looks like here.
Before a first contribution can be merged you will be asked to sign the Contributor License Agreement. A bot handles it on your pull request; it takes about ten seconds and only happens once. The CLA keeps copyright in the codebase in one place, which is what makes it possible to offer GitWarren under a commercial licence alongside the GPL, or to change licence later, without having to track down every past contributor. You keep full ownership of your work and can use it elsewhere however you like.
Support and privacy
Questions, ideas and setups worth copying go to Discussions — Q&A if you are stuck on something, Ideas for a feature, and Show and tell for an agent or remote-machine arrangement other people should steal. Bugs you can describe — what GitWarren does, and when — go to issues. Anything you would rather not post publicly goes to contact@klarluft.com.
GitWarren keeps everything on your machine: reviews live in one SQLite file in your application-data directory, the diff is read from your git worktree, and there is no account and no telemetry. The desktop app's one outbound request is the auto-update check against this repository's GitHub Releases. The website's privacy policy covers gitwarren.com itself.
License
GitWarren is free software, licensed under the GNU General Public License, version 3 or (at your option) any later version. The full text is in LICENSE.
In short: you may use, study, modify and redistribute it, including commercially. If you distribute a modified version, or a program that incorporates this one, you must release that under the GPL as well and make the source available. That reciprocity is the point — it keeps GitWarren and anything built on it open.
The copyright is held by Klarluft B.V. (Rotterdam, The Netherlands · KVK 86875590), and every contribution is covered by the CLA. Because the copyright sits in one place rather than being spread across contributors, a licence other than the GPL — for embedding GitWarren in a closed-source product, for instance — can be granted on request: email contact@klarluft.com.
Michal Wrzosek (michal@wrzosek.pl) is the creator of GitWarren and currently its main maintainer.
Copyright © 2026 Klarluft B.V.
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <https://www.gnu.org/licenses/>.Available Tools
17 toolsadd_repositoryAdd repositoryA
Start tracking a git repository. path may be any directory inside the working tree - it is resolved to the repository root before being stored, so the same repository cannot be added twice under two different paths. name defaults to the folder name. Fails with NOT_A_GIT_REPOSITORY if the path is not inside a git repository.
Inputs: path (required), name.
add_review_commentAdd review commentA
Start a new discussion on a review. Omit filePath and line for a comment on the review as a whole; give both to attach it to a line, the way a pull-request review comment works. side picks which side of the diff line counts on - "head" (the default) for the code as it will be, "base" to remark on a line the change removed. Add startLine to comment on a block rather than a single line; line is then the last line of it, and the one the whole range follows if the code moves. The line is not required to be part of the diff. A line the patch does not print is looked up in the file itself at the head, so a remark on code this branch did not touch anchors and follows that code exactly as one on a changed line does - people read these in the review's Browse files tab. Only a line that is in neither the diff nor the file (past the end of it, or on the "base" side outside the patch) is kept without an anchor; the returned thread says which happened. Comments are attributed automatically from the MCP handshake - see agent_identity.
To include a screenshot, write the file to disk first, then reference it as an ordinary markdown image:
The dropdown renders behind the modal:
The file is copied into GitWarren and the path rewritten, so the image survives /tmp being cleaned. Always write alt text - it is what agents without vision see.
If the path contains a space - "Screen Shot 2026-09-01 at 10.32.14.png", as macOS names screenshots - wrap it in angle brackets, or markdown does not read it as an image at all and it is left as plain text:
PNG, JPEG, GIF and WebP are accepted, up to 10 MB. A path that does not resolve is left in the text as written rather than failing the call, so check the returned body if it matters.
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: body (required), reviewId (required), line, side, +4 more.
agent_identityAgent identityAIdempotent
Show how comments from this session will be attributed, and optionally set a label for the session. The tool name ("Claude Code", "Codex", ...) is taken from the MCP handshake and cannot be changed - it is what makes attribution consistent across sessions. label is a short handle for this session ("auth-refactor"), worth setting when more than one agent is working the same review; it is remembered until this server process exits.
Inputs: label.
create_reviewCreate reviewA
Open a review comparing two refs in a tracked repository. baseRef is what the changes are measured against (usually the trunk) and headRef is the branch under review; the diff is taken from their merge base, like a pull request. Both refs must exist and share history, or the call fails with INVALID_INPUT. title defaults to " into ". If the head branch is checked out in a worktree, its uncommitted changes are part of the review as well - a review can be opened on work that has never been committed. Passing the same ref as both endpoints is allowed and does exactly that: the review then holds only the uncommitted work on that ref, and its title defaults to "Uncommitted work on ".
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: baseRef (required), headRef (required), repositoryId (required), title, +1 more.
delete_review_commentDelete a commentADestructiveIdempotent
Delete one message. If it was the only message in its thread, the thread goes with it. As with editing, an agent can only delete messages written by its own tool.
Inputs: id (required).
get_repositoryGet repositoryARead-only
Fetch one tracked repository by id, with its live git state.
Inputs: id (required).
get_reviewGet reviewARead-only
Fetch one review by id, with the repository it belongs to attached (including the repository path, so the changes can be inspected with git directly).
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: id (required).
list_repositoriesList repositoriesARead-only
List every git repository tracked in GitWarren, each with its live git state (whether the folder still exists, whether it is still a repository, and the current branch). Git state is read fresh on every call and is never cached.
Inputs: no named parameters.
list_review_commentsList review commentsARead-only
Every discussion on a review: review-level threads and line comments alike, each with its full message history and who wrote each message. Line threads also carry an anchor saying where they land in the code as it stands right now - "anchored" (the line is unchanged), "moved" (the code shifted and anchor.line is its current line) or "outdated" (the line is gone, so the comment may be about code that has since been rewritten). Threads about files the diff does not contain are resolved against those files at the head rather than against the patch, so a comment on unchanged code reports an honest anchor too. Check the anchor before acting on a line comment. An outdated one still carries anchorSnapshot, the code as it read when the comment was written, which is how to tell what was being objected to before it was rewritten.
A body may contain images, written as markdown pointing at a gitwarren://attachment/... URL - that is an internal token, not something to fetch. Each one is resolved in the comment's attachments array, where path is a real file on disk: read it with your own image tools. alt is the description whoever attached it wrote, and is worth reading first - it is often enough on its own, and it is all you get if you cannot see images.
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: reviewId (required).
list_reviewsList reviewsARead-only
List reviews, newest activity first. Filter with repositoryId and/or status ("open" or "closed"); omit both to list every review across all tracked repositories. A review records the two refs being compared, not the commits they resolved to - read the repository with git to see the actual changes.
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: status, repositoryId.
remove_repositoryRemove repositoryADestructiveIdempotent
Stop tracking a repository. This only removes it from GitWarren - the working copy on disk is never touched.
Inputs: id (required).
remove_reviewRemove reviewADestructiveIdempotent
Delete a review. This removes only the review record - no branch, commit or file in the repository is touched. To file a finished review away without deleting it, set its status to "closed" instead.
Inputs: id (required).
reply_to_review_commentReply to a review commentA
Add a message to an existing thread. Use this rather than opening a new thread when responding to something someone already raised, so the discussion stays in one place. Thread ids come from list_review_comments.
To include a screenshot, write the file to disk first, then reference it as an ordinary markdown image:
The dropdown renders behind the modal:
The file is copied into GitWarren and the path rewritten, so the image survives /tmp being cleaned. Always write alt text - it is what agents without vision see.
If the path contains a space - "Screen Shot 2026-09-01 at 10.32.14.png", as macOS names screenshots - wrap it in angle brackets, or markdown does not read it as an image at all and it is left as plain text:
PNG, JPEG, GIF and WebP are accepted, up to 10 MB. A path that does not resolve is left in the text as written rather than failing the call, so check the returned body if it matters.
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: body (required), threadId (required), agentLabel.
resolve_review_commentResolve or reopen a threadAIdempotent
Mark a discussion settled, or reopen one. Set resolved to true once the point has been addressed, false to bring it back. Resolving records who did it; it never deletes the messages, which stay readable.
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: resolved (required), threadId (required).
update_repositoryUpdate repositoryAIdempotent
Rename a tracked repository, or repoint it at a moved working copy. Provide at least one of name or path. A new path is validated and resolved exactly as it is when adding.
Inputs: id (required), name, path.
update_reviewUpdate reviewAIdempotent
Change a review's title, description or endpoints, or set its status to "closed" or "open" again. Provide at least one field. New refs are validated exactly as they are on creation.
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: id (required), title, status, baseRef, +2 more.
update_review_commentEdit a commentAIdempotent
Replace the text of one message. An agent can only edit messages written by its own tool - correcting yourself is expected, rewriting someone else's review is not.
Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.
When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.
Inputs: id (required), body (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 17 tools
Every tool targets a distinct resource plus action: repositories, reviews, and review comments each have clear list/get/create/update/delete boundaries. The potential confusion between add_review_comment and reply_to_review_comment is fully resolved by their descriptions (new thread vs. reply to existing thread), and resolve/update/delete comments are clearly separate operations.
The set overwhelmingly follows a snake_case verb_noun pattern (list_repositories, create_review, update_review_comment). It loses one point for minor inconsistencies: agent_identity is a noun rather than a verb-led name, and delete_review_comment uses 'delete' while the other destructive tools use 'remove'.
At 17 tools the server is slightly above the ideal 3-15 range, but the count is justified by covering two resource domains (tracked repositories and reviews) plus full threaded comment operations and an identity/attribution tool. It feels a touch heavy rather than bloated or redundant.
Repositories have full lifecycle coverage (list/get/add/update/remove), reviews have list/get/create/update/remove plus open/closed status handling through update, and comments support listing, adding, replying, resolving, editing, and deleting. The identity tool fills the attribution gap that a multi-agent review workflow needs, leaving no obvious dead ends.
Maintenance
Related MCP Connectors
Comment on AI-generated webpages; feedback flows back to your coding agent. Free, MIT, local-first.
Git collaboration for AI agents and people: tasks, hand-offs, reviews, teams, shared memory.
Versioned artifact review for people and AI agents, with contextual comments and human control.
Read your Rectifier code reviews from a coding agent. Read-only.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceA collaborative code and markdown review tool that bridges human reviewers and AI agents, enabling both to browse files, inspect git diffs, leave structured comments, and save a final review report from the same UI in real time.2MIT
- AlicenseAqualityDmaintenanceA local MCP server that provides a safe, explicit set of Git operations for version control tasks like status, diff, branching, staging, committing, fetching, merging, and pushing.135 npmMIT
- AlicenseNot gradedqualityBmaintenanceA review handoff tool for agent-driven coding sessions that captures worktree diffs, creates shareable review URLs, and streams reviewer feedback back to the agent.1ISC
- AlicenseAqualityBmaintenanceEnables humans to review AI-generated code changes through a GUI: agents freeze git diffs and add findings/diagrams, while reviewers annotate and save decisions returned as an exact correction prompt.17302 npmISC