Comparison · 2026-04

# How Selvedge compares to AgentDiff, Origin, Git AI, and BlamePrompt.

The "git blame for AI" category is fast-growing — five tools, all promising to surface the why behind agent-written code. They differ on the axes that matter: where reasoning comes from, what unit it's attached to, when it's collected, how it's stored — and whether the tool can tell an agent what was already tried and rejected before it starts.

| Reasoning source | Granularity | Mechanism | Grouping | Prior attempts | Storage
--- | --- | --- | --- | --- | --- | ---
Selvedge | Captured live, by the agent in the same context that produced the change | Entity — DB column, table, env var, dep, API route, function | MCP server — agent calls it as work happens | Changesets — named feature/task slugs across many entities | Yes — surfaces alternatives tried & rejected paths via `prior_attempts` | SQLite, zero deps
AgentDiff | Inferred post-hoc by Claude Haiku from the diff at session end | Line | Git pre/post-commit hook | None | None | JSONL on disk
Origin | Captured at commit time | Line | Git hook | None | None | Local
Git AI | Attribution metadata | Line | Git hook + Agent Trace alliance | None | None | Git notes
BlamePrompt | Prompt-only | Line | Git hook | None | None | Local

## Why "captured live" matters

AgentDiff and Origin generate reasoning after the change is made, by feeding the diff back to a second LLM call. Selvedge's reasoning is the agent's own intent, written from the same context window that produced the change — no inference, no hallucinated explanations, and an empty `reasoning` field is itself a useful signal (the agent didn't have one).

Post-hoc inference produces plausible-sounding reasoning that may be wrong, because the second LLM never saw the original prompt. Capture from the producing context is information; capture from a second LLM is paraphrase.

## Why "entity-level" matters

Most tools attribute lines. Selvedge attributes things you actually search for: `users.email`, `env/STRIPE_SECRET_KEY`, `api/v1/checkout`, `deps/stripe`. The first question after `git blame` is usually "what's the history of this column", not "what's the history of lines 40–48 of users.py".

## Why "changesets" matter

A Stripe billing rollout touches the `users` table, two new env vars, three new API routes, one dependency, and four functions across the codebase. Tag every event with `changeset:add-stripe-billing` and you can pull the entire scope back later — even if the original PR was broken into eight smaller ones over a month. None of the line-attribution tools have an analogue.

## Why "prior attempts" matters

Line attribution answers "who wrote this, and roughly why." It can't answer the question an agent actually has before it starts: "has this been tried before, and how did it turn out?" Selvedge's `prior_attempts` tool answers exactly that — given an entity, it returns the alternatives that were tried and the paths that got rejected, each with the original reasoning and the reason it was reverted. An agent about to re-add a column that was already pulled for a good reason finds out first, and changes its plan.

It's deliberately conservative: the default only returns the clear "tried, then reverted" signal, so an empty result is a trustworthy "nothing to worry about" rather than noise. No second LLM is involved — it's a templated query over the reasoning agents wrote live. None of the line-attribution competitors surface rejected paths at all.

See the worked demo transcript — an agent asked to keep mobile users signed in calls `prior_attempts`, learns the DB-token approach was tried and reverted (revocation cost), and pivots to a refresh-token endpoint instead of repeating it.

## Selvedge ↔ Agent Trace

Agent Trace (Cursor + Cognition AI, RFC Jan 2026, backed by Cloudflare, Vercel, Google Jules, Amp, OpenCode, and git-ai) is an emerging open standard for AI code attribution traces. Selvedge isn't a competitor to it — it's a compatible producer. Agent Trace is the wire format. Selvedge is the live capture + query layer that emits it.

The design for `selvedge export --format agent-trace` is published at docs/agent-trace-interop.md and lands in v0.4.0.

## When you'd pick Selvedge

- Your agent makes a lot of schema or config changes you'll need to audit later.
- You want your agent to know what was already tried and rejected on an entity before it repeats a mistake — that's `prior_attempts`.
- You roll out features that touch many entities (billing, auth migrations, deprecations) and want to query them as a unit.
- You want the reasoning at the moment the change happens, not a paraphrase of the diff.
- You'd rather use MCP than a git hook because your agent already speaks MCP.

## When something else is better

- You don't use an MCP-capable agent. (Selvedge can fall back to a git post-commit hook for inference, but capture quality drops.)
- You only need line attribution and your tooling already handles it. Pick AgentDiff or Origin.
- You want a hosted service for cross-repo aggregation today. Selvedge is local-first; the hosted layer is Phase 3.

Try it in 90 seconds

pip install selvedge && selvedge setup