Your agents forget. Your team doesn't have to.
Every agent session is a problem being solved out loud, and then the terminal closes. Codecast keeps the record searchable — so the next agent, or the next person, starts from the answer.
The most expensive thing an agent produces is thrown away
Watch an agent work on a hard bug and most of what it produces is not code. It is the investigation: the three hypotheses it ruled out, the file it read that turned out to be the culprit, the one-line experiment that proved it, the sentence where it finally says found it. Then the fix lands, the session ends, and all of that goes with it. The diff survives. The reasoning does not.
On a team this compounds. Someone else hits the same wall next month — or the same person does, in a fresh session with no memory of the last one — and an agent starts the whole investigation over from zero. The answer already existed. It just lived in a terminal that closed.
One real question
Here is a session from this repository, one week ago. The prompt was one line: why is my seo so bad — we don't even rank for codecast. Twenty-six messages later the agent had the root cause. Codecast recorded the session as it happened, so today it is one search away. Here is that search in the app, with the filters that scope it: everyone or only you, everything or only your prompts, a time window, and sort by recency or relevance:

Read that card bottom to top and it is the whole arc: the question, the diagnosis two minutes later, the deploy confirmation two days after that, and the loose end (has the fix actually deployed to prod?) that came up in review. That is what a session record looks like when it is kept. Search runs across every session on the team, yours and your teammates', and matches message content, not just titles, so a phrase the agent said in passing is enough to find the session that said it. (In a terminal, cast search returns the same hits.)
From a hit to the whole story
A search result is a pointer. Click a matching message and the session opens at that message, with the conversation around it. This is message 26, the moment the agent found it, including the mechanism, which is the part a diff can never tell you:
Found it. Your SEO is bad for one dominant, fixable reason: **your own server serves Googlebot a blank page**. Everything else is secondary. `packages/web/server/bot-meta.ts` is a link-unfurl middleware built so Slack and Twitter cards look nice. But `Googlebot`, `bingbot`, and `Applebot` are in its `BOT_UA_PATTERNS` list. When Google crawls any page, the middleware returns `ogHtml()`: a head full of meta tags and a literal empty `<body></body>`. … The unfurl middleware and SEO have opposite needs that got conflated. Slack and Discord only read `<head>` tags, so an empty body is fine for them. Google reads the body and follows links. One `isBot()` list treating both audiences the same means the feature that makes share cards pretty is the same feature that blinds Google. The fix is to split the list, not delete the middleware.
Notice what you now know that git log would never have told you: the bug was not in the SEO code at all. It was in a link-unfurl feature built for Slack, doing exactly what it was designed to do, for an audience it was never meant to serve. If you had inherited that repository and touched bot-meta.ts without this context, you would have had a fair chance of putting Google back on the wrong list.
Two more views sit in the session's header. View density set to Summary folds a long session into one short narrative, each beat a click from the message it came from: the answer to “what happened there?” without reading 465 messages. Show git diff (d) opens the nine files the session changed beside the conversation, for the moment you need to see the code after all.
Agents remember through it too
The interesting part is who else reads the record. Every codecast agent session gets a command line into it, and an agent about to start a task can ask what came before it. This part has no screen, because its reader is an agent: cast context ranks past sessions against a task. We ran it while drafting this post:
$ cast context "add a new marketing page with SEO"
<CONTEXT query="add a new marketing page with SEO">
Found 10 relevant sessions
## Most Relevant
[jx7a9s8] 4:04 PM - "Codecast monorepo setup"
Preview: ... checks run in both directions (`routes.manifest.test.ts:266`, `:317`, `:375`). Adding a manifest...
[jx7c9d2] Yesterday - "CodeCast SEO backlink campaign"
Preview: ...dy to go live on the next push to main. ```cast-canvas <div data-canvas-title="SEO fix — what cr...
[jx76rg1] Jul 22 - "Codecast market positioning launch"
Preview: ...f"> ct-39374 blog work is done and verified. Files (all under packages/web/app/(marketing)/blog/,...
… 7 more sessions
Use: cast read jx7a9s8 <range> # read session messages
cast summary jx7a9s8 # get session summary
</CONTEXT>
Ten sessions, ranked, with the two commands to go deeper printed at the bottom because the reader is expected to be an agent. It found the SEO session, the launch session that built the first blog pages, and the monorepo setup session that explains the route manifest checks a new page has to pass — three things a new agent would otherwise have had to rediscover by reading code, or worse, by getting it wrong once. Memory stops being something you have to remember to write down. Every session is already the note.
Whose memory
Search is scoped the way your team is. Sessions in a shared project are searchable by the whole team; sessions in a private project are searchable only by their owner. The Everyone / Only mine switch in the screenshot is that boundary made visible. Content matches cover the last thirty days in full; older sessions match by title and summary, so a session from March still surfaces by what it was about. Nothing is searchable that you did not choose to share.
A few weeks of running agents this way changes a habit. You stop asking a teammate “did anyone ever look at this?” and start asking the record — and the record answers with the session, the reasoning, and the exact message where someone, or something, found it.
Codecast is where your team sees, steers, and remembers every coding agent session — any agent, any machine.
The quoted message and the cast context capture are genuine, from the author's account on 2026-08-15, and the session they point at (jx7c9d2) is a real session from the codecast repository, one week earlier. Excerpts are trimmed to the codecast repository; every omission is marked …. The screenshot is the web app's search page cropped to its content area, joined from two captures of the same results, the query header and the result card for that session; one card between them, for the session that wrote this post, is left out.