What launched

AVP went up on Product Hunt with a one-line pitch: “Open source alternative to Git for AI coding agents.” The listing sorts it under Git clients and LLM developer tools, and points to avp.murmell.com and a GitHub repository. At the time of writing the launch sits around rank 20 for the day with roughly 76 upvotes - early, but not invisible.

The sentence that actually explains the product is further down the page:

Worktrees isolate your agents. AVP integrates them: every change proven on the exact head of main before it lands.

That is a much narrower and more interesting claim than “a new Git”.

The real problem it is aiming at

If you have run more than one coding agent on the same repository, you already know the shape of the failure. Two agents, one working tree, and one of them reverts the other’s edit mid-task. The standard answer is git worktree: give each agent its own checkout so their file writes do not collide.

Worktrees solve isolation and create a new problem. You now have N branches that all drifted from main at different moments, and integrating them is a manual sequence of rebases, conflict resolution, and test runs. The failure mode is subtle: a change that passed in its own worktree can break the moment it lands, because the base it was tested against is no longer the base it is merging into.

“Proven on the exact head of main before it lands” is a direct answer to that. It implies each candidate change is re-validated against current main rather than against whatever commit the agent started from.

Whether the implementation lives up to that sentence is a separate question, and one you should answer from the repository rather than the launch copy.

What to verify before you build on it

The Product Hunt page describes intent, not behaviour. Before adopting it for anything that matters:

  • Licence. “Open source” covers everything from MIT to source-available licences with commercial restrictions. Read the actual file.
  • Conflict behaviour. What happens when two agent changes touch the same function? Does it rebase, merge, or reject?
  • The proof step. Is “proven on the exact head of main” a test run, a build, or just a fast-forward check? Only the first two catch real breakage.
  • Windows. Git worktrees on Windows hit path-length and file-locking problems that Linux-first tooling often misses. If your agents run on Windows desktops, test there specifically.
  • Audit trail. Can you see which agent produced which commit, and what it was asked to do? Without that, a bad change is unattributable.
  • Offline behaviour. Agent tooling that assumes a hosted service will fail the first time your network does.

Why this matters even if you do not switch

The interesting part of AVP is not the product, it is the admission. Agent tooling has spent two years optimising the model and the prompt, and the thing that actually breaks in production is the state layer underneath: which files, which branch, which version of the truth.

That problem shows up outside coding too. A desktop agent that edits spreadsheets and documents has the same failure - two tasks, one file, last writer wins, nobody can say which version was reviewed. Version control for agent output is becoming the boring prerequisite for letting agents run unattended at all.

If you are still at the stage where one agent does one task while you watch, you do not need a new Git layer. You need a commit boundary per task, and a rule that the agent never edits a file it did not open. MOOGH is built around that model: a desktop agent on Windows that acts on the applications you already use, with each run scoped to what you handed it.

FAQ

Does AVP replace git worktree?

By its own description it builds on the same idea rather than replacing it: worktrees provide the isolation, AVP provides the integration and the pre-landing check.

Is it production-ready?

There is no way to tell from a launch page. Treat a rank-20 Product Hunt debut as a signal that the problem is real, not as evidence that the implementation is mature.