I think this is very interesting but you need a better slogan.

Many people here made comments such as “why do I need another SVC since agents are pretty good with git”, which means they barely read your blurb and did not understand your project.

People in this thread seem to be too focused on the agent creating a git log. This seems to be solving a different problem than that does.

When you're interacting with agents, multiple prompts may reasonable culminate in a single commit. It may be useful to track or undo things between commits - at the prompt level. I personally have a workflow when I use Jujutsu (jj) for git already, and this slotted in very nicely to solve this problem. The auto-committing in jj makes it very easy and natural to compare diffs between prompts, and undo specific chunks or restore previous states without making a new commit every prompt. I only finish a commit, giving it a message and advancing the branch, once I've iteratively dialed in the changes I want.

I probably won't use this tool since I already have a flow that works for me, but maybe this will help people see why such a tool can be helpful.

Edit: fixed typo

Just use git. If your agent (especially claude) doesnt seem to know how, there are skills and hooks and other options to make it work. My 2c.

This seems easily solved with a tool use hook that calls git add .; git commit a -m "<tool description>", specifying an alternate .git directory if desired

Everything but trivial changes should go through a prompt -> plan -> impl phase where you revise a concrete plan file until it's ready for impl.

Now impl is just a derivation of the plan, and the plan gets checked in with the same commit so that you can see the why, the intent, the objective, the research that informed the decisions.

Much simpler, and a much, much more effective process than prompt -> impl.

Very cool approach! We build something super similar, also going for content addressed storage and compare&swap as fundamental primitives.

Also commit dag based, but we also wrote this whole knowledge graph / triple-store CRDT data format on top.[1]

We also have p2p syncing of the history so you can use it to track your local work but also to have your agents coordinate within your team.

We had our agents build their own tools on top of that substrate, that way we're vendor independent, this stuff works everywhere from claude web, to self hosted openclaw, you only need to tell your agent to use the faculties.

Because the substrate takes care of everything, every new faculty you write on top of that inherits all of the same properties.

1: https://github.com/triblespace/triblespace-rs

2: https://github.com/triblespace/faculties

I found LLMs to be really smart with command-line git.

This week I told DeepSeek v4 Flash (max variant) to scavenge for all changes and additions of a specific feature of the project and build a report of the feature timeline with example code and rationale behind the changes.

It fired a ton of read-only git commands (isolated inside Docker) and came up with a neat markdown report of the feature from inception to current state.

If DS4 Flash can do it, for SOTA LLMs like GPT 5.5 and Opus it should be a walk in the park.

That said I don't let LLMs commit. I like to take a close look at every change before committing. Early changes are cheaper.

Hey, that's cool. Does this support conversation lookups? Like, "find this conversation we talked about yesterday"? I built a similar tool to this, although Regent seems much more elegant: https://github.com/divmgl/clancey/

I think the idea of tracking intent in git commits is a great idea but it feels to me like this might be reducible to some prompts/extending git/pre-commit hooks?

Agents can use git FWIW, and you can tell them to search old sessions by saying "Search through sessions in ~/.codex/sessions" and it'll find the most appropriate tools for doing so that is installed already. You can even add this to your system prompt or AGENTS.md and now you don't even have to prompt for it, it'll just look up the session history by itself.

Why this isn't built-in, I dunno, but been possible and easy for a very long time already, and works for any agent harness out there (as long as they persist sessions that is).

Personally I make the agent justify and explain things in the git commits, where is where that info went before agents anyways too, then have some sentences in my AGENTS.md about reading recent commits before doing changes, and using it whenever I prompt for history that isn't part of the current session. Seems to work perfectly fine.

quite interested in this but I'm working pi/omp only at the moment.

Inspired by entire.io I've vibed a super small extension that seems similar to this: https://github.com/janmechtel/pintire

I expect this feature to eventually end up in the harness

Hey, this is cool work. By any chance, did you see Cloudflare Artifacts?

https://blog.cloudflare.com/artifacts-git-for-agents-beta/

Small recommendation: Speed up the demo on the Github page. That would reduce the number of folks that drop off the page waiting for the command-line typing.

1. Tests look anemic: https://github.com/regent-vcs/re_gent/tree/main/test

2. How does it compare with http://usegitai.com/ and https://entire.io/ ? Another Show HN: https://news.ycombinator.com/item?id=48057104

3. Please add it to other registries, esp. those compatible with mise, e.g., https://github.com/aquaproj/aqua-registry

Nice project. The interface feels clean and fast.

What's git for AI agents? git. What's a browser for AI agents? a browser. What's a Flux Capacitor for AI agents? a Flux Capacitor. You get the point.

This is brilliant. Does it only work with Claude right now? Will it work with any agent built on the Claude Agent SDK?

just curious since it reminds me a bit. Have you / someone tried https://entire.io/ (I'm not affiliated at all, so it is not a plug).

That's a good idea. I think you should develop it to make it more versatile.

None of these X-for-agents seem to motivate why they don’t use X.

I am all for extremely granular control of agents. Good work.

can’t you just make agent hooks that do this with plain git?

my agent rebased and forcepushed with conflicts...

Fun idea! There's frankly a lot to learn from reviewing agent sessions.

hm, I can’t find the link?

I think of git more like a defense and quality control against AI slop than something that should be automated

Cool idea. Time will tell how it matures. It doesn't look trivial. Definitely should beat my current "scan the history" approach. Couple questions arose while reading the README:

- Would it integrate with rtk? Rtk is a token saver that shortens native output of got (and other) commands. - Does it track feature branches? - Is there garbage collection when history is rewriting (rebase before PR or removal of credential files.. ) or "simplification" of data as it gets older (Claude session logs lost...)?

Wishing you all the best with the project.

unfortunately, agents have decades of examples for how to use git, bearish on any tool that deviates from git

every show hn now is now

cool but look at myproject.com