Documentation
Recall

See which agent session wrote a line

Set Blame to Sessions on any file to see the session behind each line, and open the conversation where it was decided.

4 min read

git blame tells you who committed a line. When an agent wrote it, that is only the person who ran the agent, and the reasoning is gone: the request that asked for it, the alternatives it rejected, the test that settled it. Codecast keeps that reasoning. For any line an agent wrote while codecast was running, you can see which session wrote it and open the conversation.

A file in the Code view with Blame set to Sessions: a strip reading "94% by 3 sessions" with a chip per session, and the session behind each block of lines in the gutter
Blame set to Sessions. The strip lists the sessions that wrote the file; the gutter names the one behind each block.

Turn on session blame

  1. Open Code in the sidebar, then a repository and a file.
  2. In the bar above the file, set Blame to Sessions. Press B to cycle Off, Git and Sessions.

Git shows ordinary blame, with commits and authors, when that is what you need.

Read the gutter

The gutter names the session behind each block of lines, with how long ago it was written. A block a person wrote outside any session shows their git name instead, like ordinary blame. Hover a block to see who ran the session, the commit, and how codecast traced the line to it.

Use the session strip

The strip above the file sums it up: how much of the file traces to a session ("94% by 3 sessions"), then a chip per session with its title, who ran it and how many lines it wrote.

  • Hover a chip to light up that session's lines wherever they are in the file.
  • Click a chip to keep them lit and jump to the first one.
  • Click the speech bubble at the end of a chip to open the conversation. A lock in its place means the session is private to someone else: you can see that it exists, not read it.
The session strip with one chip hovered and its lines highlighted down the file
Hovering a chip lights up every line that session wrote.

Ask your agent why

You don't have to open the Code view. Ask an agent with Memory on:

  • "Why does line 42 of src/webhooks.ts wait before retrying?"
  • "Which session added the retry cap in the webhook handler, and what was the reason?"
  • "Who changed the session timeout last, and did they mean to?"

The agent finds the session that wrote the line, reads the part of the conversation where it was decided, and answers from the author's own reasoning, with a link to that message.

When an agent session commits, codecast adds a last line to the commit message that links back to the session, such as Codecast-Session: https://codecast.sh/conversation/jx74qbm…. Because the link is part of the commit message, it survives rebases, squash merges and any git host, and anyone reading git log can follow it.

In codecast, a commit page and a pull request's commit list show that line as the session's name, which you click to open the conversation.

A commit page in codecast showing the session that made the commit by name
A commit page names the session behind the commit.

Following the link still needs access to the session: it points at the conversation, it doesn't share it. Codecast adds the line only for sessions shared with your team, so a private session never leaves a link in a shared history. It covers commits Claude Code makes directly; commits made by a script the agent runs, or by other agents, don't get the line, and codecast traces those from its own record of the session's edits instead.

What it covers

  • Work done while codecast was running, in the agents it records: Claude Code, Codex, Cursor and Gemini. Code written before you installed codecast keeps its ordinary git blame.
  • Only what you can see. A session shows by name only if you can open it; otherwise you see a lock.
  • Committed lines. The Code view shows a branch as it is on your git host.

Other tools

Git AI and Agent Blame write attribution into the repository itself as git notes, captured by hooks installed before the code is written. Anyone with a clone can read it, with no account. Choose them when attribution has to live in the repository; choose codecast when you want the whole conversation behind a line, or when the code was written before anyone installed anything. They work side by side.

For agents and scripts

cast blame <file> prints the same session attribution in a terminal, and is what agents use to answer "why is this line here".

More guides
Agent features: what your agents know how to do
Switch features on for each computer, and every new session there learns to remember, delegate, track work, show results and use your machine.
Memory: agents that look up past work
Your agents search every session you can see, across your machines, agents and team, and answer with the session they found it in.
Let Claude, Cursor and Codex read your codecast
Add codecast.sh/mcp to an agent that runs outside codecast, sign in once, and it reads your docs, tasks, plans, pages and sessions as you, read only.
Search your history across every machine
Every computer you connect sends its sessions to one history, searchable from the web, the Mac app and your iPhone.
Messaging between sessions
Your sessions hand each other results and answers directly, so you stop relaying text between them.
Stable context: sessions that know what's been happening
New sessions start with a short list of what you and your team worked on recently, so they pick up threads instead of starting cold.
See your whole team's agent sessions in one place
Every session your team runs, on every machine and agent, in one live Activity page and inbox, shared per folder.
Use Codecast with T3 Code
Threads you start in T3 Code appear in Codecast with no setup, beside every session you run anywhere else, ready to search, steer and share. What you get on top, and what stays in T3 Code.
Use Codecast with OpenCode
Sessions you run in the OpenCode TUI appear in Codecast within seconds, with no plugin. Reply to them from the app, start new OpenCode sessions there, and search them beside every other agent you use.
Share a session with your team
Choose what the team sees of a session, share it by link or a few messages at a time, and how that compares to other tools.
Pinned thread state
The agent keeps one short note on each session saying where it stands, above the composer and on its inbox card.
Decisions: asking without interrupting
Agents put the calls only you can make on one Decisions page you clear when you choose to, and each answer goes back to the session that asked.
Team chat with your agents in the room
Channels, threads and DMs where you can hand a session or a role something by mentioning it, while agents stay quiet unless they're needed.
Huddles, transcripts and walkie
Every huddle is transcribed under each speaker's name and leaves a summary, so your agents can quote what was said, and a session can join the call.
Workers, forks and switching agents
Your agent can hand work to workers that report back to it, and you can fork a conversation to try two directions from the same point.
Tasks and plans
Agents file the work they take on, post progress and close it with what they verified, and you follow it on the Tasks and Plans pages.
Triggers
Agents schedule their own follow-ups, once, on a schedule or on a GitHub or Linear event, and you can set one yourself from the Triggers page.
Workflows
A fixed sequence of agent steps, checks and approval gates that runs the same way every time and waits for you where you want a say.
Orchestration
Hand an agent a whole plan and it runs a team: implementers working in parallel, a reviewer on every task and critics on the result.
Pull requests and issues
Every pull request gets a page with its checks and threads, the session that opened it fixes what reviewers and CI flag, and Linear or GitHub issues become tasks.
The org: roles that look after your work
Give lasting work to a role with an area, a charter and a standing session, and approve the changes your agents propose to the org.
Let agents use your Chrome
Agents check pages in the Chrome you already use, logins included, from their own background tabs. Screenshots and errors come back to the conversation.
Vault: keys, logins and sign-ins for your agents
Fill a credential once and every agent on every machine can use it, without the value ever entering a conversation.
Computer use: agents in your Mac apps
Agents work in Preview, Slack, System Settings or your own desktop build, in the background, with an orange pointer that shows where they act.
Typecheck: one shared check for every agent
With Typecheck on, agents on a computer share one typecheck per project, so checks answer in seconds and a busy machine stays usable.
Skills: slash commands for the jobs you repeat
Type / in a Claude Code session to pick up work, hand it over, get a second opinion or ship a pull request, the same careful way every time.
Run sessions on other machines and in the cloud
Start a session on another computer or a cloud machine in your AWS account, move it there and back, and watch it from anywhere.
Codex Cloud tasks in codecast
Bring your Codex Cloud tasks into your inbox, start new ones with several attempts, and turn the result into a pull request or local changes.
Usage limits are a pause
When a Claude plan runs out, sessions wait for the reset or continue on another account you've saved, instead of stopping for good.
The visual canvas
Agents answer with charts, comparisons and diagrams drawn right in the conversation when a picture says it better than text.
Published pages
Agents turn reports and mockups into pages with their own link that you can share, gate, and get comments on.
Why codecast feels instant, even offline
Everything you see comes from a copy on your device that the server keeps current, so screens open at once, your edits show immediately, and nothing is lost offline.
Taking longer than usualOffline · reloads when back