公式MCP Gitサーバーに「変更なし」のままコミットを頼んだら、エラー無く何度でも積み上がったA hands-on investigation revealed that the official MCP Git server silently…

A hands-on investigation has surfaced a subtle but consequential flaw in the official Model Context Protocol (MCP) Git server: when an agent asks it to commit while the working tree contains no changes, the server does not raise an error but instead quietly produces an empty commit, and it will keep doing so on every subsequent request. For teams experimenting with AI agents that drive version control on their behalf, this behavior is worth understanding because it can silently pollute a repository's history without any signal that something has gone wrong.

The core issue is a divergence from how the standard Git command-line client behaves. When a developer runs git commit with nothing staged, Git normally refuses and prints a message such as "nothing to commit, working tree clean," returning a non-zero exit code. That guard is a safety mechanism: it prevents accidental commits and gives scripts a clear way to detect that there was nothing to record. The MCP Git server, according to the investigation, does not reproduce this guard. A commit call with an unchanged working tree returns successfully and appends a new empty commit, and repeated calls stack additional empty commits indefinitely.

The most likely explanation lies in the implementation layer. The official server is written in Python and appears to rely on a Git library rather than shelling out to the git binary. Libraries such as GitPython expose a commit operation that writes a commit object directly from the current index, and by default they do not replicate the CLI's "nothing to commit" check unless the caller explicitly compares the index against HEAD first. If the server simply forwards the agent's request to that library call, the empty-commit outcome follows naturally. This is a plausible reading of the symptoms rather than a confirmed root cause, but it is consistent with the observed lack of an error and the ease with which duplicate commits accumulate.

To put this in context, MCP is an open protocol, introduced by Anthropic, that standardizes how large language model applications connect to external tools and data sources. The ecosystem ships a collection of reference servers—covering filesystems, databases, web fetching, and Git among others—that are meant to demonstrate the protocol and provide ready-made capabilities. Because these reference servers are frequently adopted as-is inside agent frameworks, editors, and desktop clients, a defect in one of them can propagate widely. The Git server in particular is attractive for coding agents that need to inspect status, read diffs, stage files, and record commits as part of an automated workflow.

The reliability concern becomes clearer when you consider how autonomous agents operate. An agent may loop through a plan, attempt a commit at the end of each step, and rely on the tool's response to decide what to do next. If a commit with no changes returns success instead of a "nothing to commit" signal, the agent has no way to distinguish a real commit from a no-op. Over a long-running task, or in a retry loop, this can produce a chain of meaningless empty commits that obscure the actual history, complicate code review, and interfere with tools that assume each commit represents a change. In shared repositories, such noise can also confuse continuous integration triggers and changelog generation.

Mitigations are relatively straightforward while a fix is pending. Users can check repository status before committing and skip the commit when the working tree is clean, rely on the git CLI directly for commit steps, or add validation in the agent's orchestration layer that inspects the diff before invoking the tool. Anyone maintaining a fork could add an explicit comparison between the index and HEAD, returning an informative error when nothing has changed, which would bring the server's behavior in line with the familiar command-line semantics.

More broadly, the finding is a reminder that MCP servers sit on the boundary between deterministic developer tooling and probabilistic AI behavior, where small mismatches in error handling can have outsized effects. As agent-driven development matures, careful parity with the underlying tools' safety checks is likely to matter as much as adding new capabilities, and reporting issues like this one upstream helps the reference implementations become dependable foundations rather than sources of hidden surprises.