Git for your AI agent’s actions. Undo, trace, and control every step. re_gent shows what your coding agent changed, which prompt caused it, and lets you roll back agent work across files and sessions.
The most valuable thing in a long-running agent is not just autonomy, it is knowing why the next attempt is still justified. I would want the loop to expose what changed since the previous try: new context, better verifier signal, reduced uncertainty, or a narrower task. Without that, autonomous retries quietly turn into expensive repetition.
The audit trail problem with AI agents is real. When you're running agents that touch customer-facing outputs - outbound emails, content, CRM updates - knowing what ran, when, and what changed isn't nice-to-have, it becomes essential fast. Git for humans works because humans understand state. Curious how re_gent handles conflicts when two agents modify the same object in parallel - is it last-write-wins or do you surface the conflict for human resolution?
The gap Re_gent is filling: linking file changes back to the specific agent action or prompt that caused them is something no standard version control handles. But What I'm curious about is how it handles multi-agent sessions where two agents modify the same file in sequence. Does it trace each change to the right agent independently, or does the attribution get murky
the observability gap for agent work is real and getting worse as agents do more. you end up with a codebase that changed in ways you can explain at a high level but can't trace precisely. version control for human code exists because we learned that lesson the hard way. learning it again for agent output was probably inevitable
I run parallel Claude Code sessions on my local machine with git worktrees, so each agent is editing its own set of files. Will Re_gent work for that setup?
The "blame" feature is the most interesting piece here. Tracing a line of code back to its originating prompt is genuinely hard when agent sessions involve compaction, branching reasoning, and multi-step tool calls. How is Re_gent defining the unit of attribution? If a single prompt triggers a chain of 8 tool calls that each touch different files, does blame point to the root prompt, the specific tool call, or both? That granularity decision shapes how useful the audit trail is for anything compliance-adjacent.
Version control for agent activity is something I didn't know I needed until now. When an agent makes a bad decision mid-task, rollback is exactly what you want. Does it track just file changes or the full agent decision chain?
This solves a real pain point. I run 15+ automated agents in production and the worst debugging scenario is "something changed overnight and I don't know which agent did it." Right now my workaround is JSON audit trails per agent, but tracing a bad outcome back to the specific prompt that caused it is still manual detective work.
The multi-file rollback across sessions is the killer feature. Agent mistakes rarely touch just one file — they cascade. Does Re_gent handle rollbacks in systems where Agent A's output feeds into Agent B's input? That chain reaction is where most agent damage happens in my experience.
This solves a real problem. The biggest issue with coding agents right now isn't that they make mistakes, it's that nobody can tell you exactly what changed and why. Being able to trace a change back to the prompt that caused it is huge for teams where multiple people are using agents on the same codebase. Curious — does it handle cases where an agent modifies something across sessions? Like if today's prompt undoes something from yesterday's session, does the timeline surface that conflict?
Congrats on the launch! Version control for agent output is an underrated problem, when you're shipping content or code with AI, auditability matters as much as quality. The GitHub integration is the right move. What does a rollback actually look like in practice for an agent-generated artifact?
Changes are also visible in Claude Code. So the value is that you can review changes in the history, right? Am I understanding correctly?
Git shows what changed, but never why — that gap gets really painful when an agent edits 10 files while you're away and something breaks. The rgt blame feature is what caught my attention — tracing a line of code back to the exact prompt that caused it is genuinely useful for debugging. Curious if it works with Claude Code already or if that's still on the roadmap?
Treating agent activity as a versioned artifact you can diff and revert is genuinely clever. Most teams just log outputs and hope. At RetainSure we've felt the pain of debugging a bad agent decision without any state history to trace it back through. Does Re_gent support mid-run checkpointing so you can fork from a specific state, or is versioning scoped to full run boundaries?
Linking agent file changes to the exact prompt that triggered them is genuinely novel. Most agent frameworks hand you a diff with no causal chain. We've been burned by cascading agent edits across services where figuring out which session introduced a bug takes forever. How do you handle rollback when the agent touched external state or APIs? Is it purely file-level undo or does re_gent track side effects too?
This hits a pain point I've run into personally. I added LangSmith tracing to my own agentic project specifically because when something broke mid-session I had no way to reconstruct which tool call or retrieval path caused it.. just vibes and scrolling. Re_gent feels like that same observability idea but applied at the file/code level, which is actually where it hurts more. The prompt-to-diff linking is the feature I'd use most.. knowing which instruction caused a specific file change is genuinely useful for debugging agent loops that go wrong on step 4 of 7.
Curious how you're handling branching though.. if an agent takes two different approaches across sessions on the same file, does re_gent track those as separate branches or does it flatten everything into one linear history? That distinction matters a lot once agents start doing exploratory work.
Does it store the natural-language prompt alongside the change, or only metadata about the session? Nice work!
Hi Product Hunt Community 🥰
Git tells you what changed, but not what the agent did to get there.
When an agent breaks something, or if it decides to just delete necessary code we're often stuck reconstructing the session from memory (assuming you caught it before /compact)
So I built re_gent: version control for AI agent activity.
With re_gent, you can: • Trace what your agent did, step by step • Blame a line of code back to the prompt/session that caused it • Rewind agent work across code and conversation • Keep history even when sessions get compacted or fragmented
And I think this is just the enabler for a lot more: - Sharing full-context conversations with teammates - Skills that let an agent investigate its own past work - Building richer context from an agent's decision history - And Much more !
Would love any feedback, thoughts, or feature requests drop em below!
YOUR AGENT DESREVES TO BE BLAMED 🤜 🤖 🤛
About Re_gent on Product Hunt
“Version Control for AI agent Activity”
Re_gent launched on Product Hunt on May 20th, 2026 and earned 167 upvotes and 32 comments, placing #6 on the daily leaderboard. Git for your AI agent’s actions. Undo, trace, and control every step. re_gent shows what your coding agent changed, which prompt caused it, and lets you roll back agent work across files and sessions.
Re_gent was featured in Open Source (68.4k followers), Developer Tools (512.8k followers) and GitHub (41.2k followers) on Product Hunt. Together, these topics include over 102.3k products, making this a competitive space to launch in.
Who hunted Re_gent?
Re_gent was hunted by SHY. A “hunter” on Product Hunt is the community member who submits a product to the platform — uploading the images, the link, and tagging the makers behind it. Hunters typically write the first comment explaining why a product is worth attention, and their followers are notified the moment they post. Around 79% of featured launches on Product Hunt are self-hunted by their makers, but a well-known hunter still acts as a signal of quality to the rest of the community. See the full all-time top hunters leaderboard to discover who is shaping the Product Hunt ecosystem.
Want to see how Re_gent stacked up against nearby launches in real time? Check out the live launch dashboard for upvote speed charts, proximity comparisons, and more analytics.
SHY
The most valuable thing in a long-running agent is not just autonomy, it is knowing why the next attempt is still justified. I would want the loop to expose what changed since the previous try: new context, better verifier signal, reduced uncertainty, or a narrower task. Without that, autonomous retries quietly turn into expensive repetition.