git blame for AI agents
When an agent writes the line, the author column goes blank. Codecast's blame fills it back in, with the conversation that wrote it.
The author column is going blank
Open a file your team shipped last month and run git blame. Every line carries an author, a date, a commit message. Now ask the author why line 8 imports what it imports. More and more often, there is nobody to ask. An agent wrote it, in a terminal session that closed hours ago, and everything it knew while writing — the files it read, the approach it rejected, the reason it landed here — closed with the process.
Agents already write a large share of the code that ships. In a controlled study of a large enterprise rollout, engineers given command-line agents merged 24% more pull requests per day, rising to 50% for the ones who used them five or more days a week (Microsoft, 2026). The commit still lands under a human name, because a human ran git commit. But git blame answers what changed and when. The why — the part you actually need during review — lived in the conversation, and the conversation is gone.
The gap this leaves
This would be a footnote if reviewing agent code were easy. It is not; it is the bottleneck. Simon Willison, who moved to running agents in parallel through 2025, puts it plainly: the binding constraint is review capacity, not how fast the agents produce code.
And developers do not extend the benefit of the doubt. In Stack Overflow's 2025 developer survey, 46% said they distrust the accuracy of AI output, and 66% named “almost right” code as their single biggest frustration. DORA's 2025 report found roughly 30% still place little or no trust in AI-generated code. “Almost right” is the worst kind of line to inherit: it passes a glance and fails under load, and the one who could explain it is a stateless process that already exited. So you re-derive the intent by hand — slower than if you had written the line yourself.
Blame by session
git blame answers who wrote this. For agent-written code the useful answer is not a person; it is the conversation. So codecast's blame swaps that column: the author of each line is the codecast session that produced it. Nothing about your workflow changes. You still run agents in a terminal and still commit under your own name. The daemon watches the sessions as they happen and keeps the mapping from line to conversation, so the attribution is there when you go looking for it.
You find it where you read code. Open a repository in codecast, open any file from the Code tab (or from a pull request's Files tab, or a commit), and the file's toolbar has a Blame switch with three positions: Off, Git and Sessions. The b key cycles them. Here is a file from this repository, set to Sessions:

Read the gutter. Each block of lines carries a session's title and age: Cross-device session sync, Production deployment, Codecast ownership model refactor. Rows that show only Ashot Petrosian predate the record or came from an ordinary hand edit; blame does not invent an author it does not have. The strip above the code steps back from lines to sessions: 70% by 41 sessions, then one chip per conversation with how many of its lines survive. Hover a chip and its lines light up; click it and the view jumps to the first of them and keeps them lit. That strip is the map of where the file came from, rebuilt from agent work that would otherwise have evaporated at the end of each session.
From a line to the conversation
The point is not the label. The point is that the label is a link. Take line 18, which imports listSessionOwnerIds. Blame says it came from Codecast ownership model refactor. Open that session and you see why the import is here at all: the refactor made ownership an independent set, so notifications had to resolve a list of owners instead of a single author. That reason is one click from the line. Not guessed from a commit summary, but the actual conversation, prompt and dead ends included.
The same attribution reaches the places code is read outside the app. In VS Code and Cursor, the codecast extension shows the session that wrote the current line at the end of the line, the way GitLens shows the commit, and opens the conversation behind it. In a terminal, cast blame is a drop-in for git blame with the session in the author column; its porcelain output matches git's and adds codecast-* keys (session, title, url, and the exact message), so anything that already shells out to git blame can call it instead.
Blame is one query over the record
Line attribution is one view of a larger thing: every agent conversation your team has run, kept and searchable instead of discarded when the terminal closes. The Search page finds a phrase in any of them, and the repository's own Search and Sessions tabs scope it to one codebase. It spans agents and machines — Claude Code, Codex, Cursor, Gemini — not one vendor's cloud runs, because the daemon watches the local sessions you already run, wherever you run them.
This is where it stops being a personal convenience. The person who ran git commit may have skimmed the diff and approved it; six weeks later the teammate who has to change that code is a different person again. With the record, the author to ask is attached to the line for both of them. The reasoning outlives the session, the reviewer, and the terminal that produced it.
That is the whole idea, and it is why the author column does not have to stay blank.
Codecast is where your team sees, steers, and remembers every coding agent session — any agent, any machine.
Sources: Stack Overflow 2025 Developer Survey; DORA 2025 State of AI-assisted Software Development; a controlled study of a large enterprise command-line agent rollout (Microsoft, 2026); Simon Willison on parallel agents. The screenshot is the codecast web app's file page for packages/convex/convex/notifications.ts in this repository, captured 2026-10-09 with Blame set to Sessions and cropped to the content column.