Documentation
Recall

Give Claude Code memory across sessions and teammates

Not notes files: every session can search, read, and watch every other session your team has run. The commands, the scopes, and how agents use them.

$cast install memory

Every coding agent session starts from scratch unless something carries context forward. The memory snippet gives agents that something: commands to search all past sessions, read any conversation, watch live ones, and pull relevant prior work into the current task. Memory works across tools — a Claude Code session can recall what was built in Cursor — and across the team, so an agent can learn from a colleague's session as easily as its own.

Memory is the foundation snippet: installing it via the snippet system also enables messaging by default, and the tasks and plans snippet rides along with it.

cast memory        # install
cast install memory --disable

Search and browse

The snippet teaches agents to search proactively — when starting a task, when debugging, when the user references previous work — and to parallelize searches across topics. Default scope is the team, from the current directory's project:

cast search "auth"                # team-wide search
cast search "auth" --mine         # only my sessions
cast search "auth" -m samvit      # a specific member
cast search "auth" -g -s 7d       # all teams, last 7 days
cast feed                         # recent team sessions
cast feed --state needs-input     # filter by work state
cast read jx7c6zk 15:25           # read messages 15–25 of a session
cast read '<share-url>#msg-<id>'  # read a window around a linked message
cast link jx7c6zk 42              # mint a deep link to any object

Search is hybrid: keyword matching combined with semantic similarity, with a fallback to title search under load. Results return original conversation fragments, not summaries, so the agent gets precise, quotable context.

Watching sessions live

cast sessions is the state axis of memory — not what was said, but where every session stands right now:

cast sessions                     # snapshot, grouped most actionable first
cast sessions -w                  # live stream: one line per work state change
cast sessions -w --json           # …as NDJSON events for scripting
cast sessions --label fleet -w    # watch every session filed under a label
cast sessions --messages -w       # follow messages across live sessions

The -w stream is silent until something changes, which makes it a reliable wake signal for orchestration loops (see messaging for the spawn → watch → send pattern). needs_input means the ball is in your court — the session finished its turn, asked a question, or hit a permission prompt.

Labels are personal filing: cast label set api jx7c6zk files a session under a name, and every browse command takes --label to filter by it.

Analysis and continuity

cast diff jx7c6zk                 # files changed, commits, tools used
cast diff --today                 # aggregate today's work
cast summary jx7c6zk              # goal, approach, outcome, files
cast context "implement auth"     # find relevant prior sessions before starting
cast ask "how does session sync work"   # natural language answer across sessions
cast handoff                      # generate a context transfer document
cast decisions add "Use Stripe Checkout" --reason "handles SCA"
cast decisions list

cast context is the habit that pays off most: run it before starting anything and the agent begins with the three most relevant prior sessions instead of rediscovering them. cast handoff closes the other end — it distills the current session's goal, approach, and open items into a document the next session can start from.

Ambient recall

Search is recall on demand. Ambient awareness is recall pushed: with stable mode on, every new session starts with a feed of recent sessions already in context, no search required. The two compose — the feed tells the agent which sessions exist and their state; cast read and cast search go deep on the ones that matter.

More guides
How agent snippets work
cast install writes versioned instruction sections into your agents' own config files. This is the mechanism every other guide builds on.
How to search your Claude Code history across every machine
Claude Code keeps sessions on the machine that ran them. The built in picker, two local search tools, and how codecast searches every machine and every agent at once.
How to find which AI agent session wrote a line of code
git blame names whoever committed a line. cast blame names the agent session that wrote it and opens the exact message; Git AI and Agent Blame solve it with git notes instead.
Messaging between sessions
cast send turns sessions into teammates: any session can message any other, including a teammate's, and manage what the human sees in the inbox.
Ambient awareness
Stable mode injects a live feed of recent sessions into every new session at start. Combined with messaging, sessions know about each other without being told.
See your whole team's Claude Code sessions in one place
Claude Code already writes every session to disk. The codecast daemon syncs those files — plus Codex, Cursor, and Gemini — into one live team feed, inbox, and searchable record.
How to share a Claude Code session with your team
Three different asks hide behind that sentence: read a finished conversation, watch a running one, or make every session visible by default. What Anthropic ships, what Lore does, and where codecast fits.
Pinned thread state
cast state keeps one agent-written line saying where a thread stands, pinned above the composer and on the inbox card, with its staleness on show.
Decisions: asking without interrupting
cast decide puts a question, its options and the reasoning into a queue you clear when you choose to. The answer returns to the agent as a message.
Team chat that agents take part in
Channels, threads and direct messages where a mention can wake a role or a session, agent lines are capped, and a Slack workspace mirrors in.
Huddles and walkie
Every huddle is transcribed with exact speaker attribution and leaves a digest, so an agent can quote what was said on the call.
Forks and spawned sessions
cast spawn --subagent delegates a worker that nests under the session that launched it; plain cast spawn and cast fork start independent threads in the human's inbox.
Tasks and plans
The work tracking layer agents report into: tasks, plans, binding, comments, and the dashboard that watches it all.
Triggers
Follow-up work that runs after the session ends: delayed, recurring, or fired by a GitHub event.
Workflows
Execution graphs in DOT syntax: agent steps, shell commands, conditions, and human approval gates.
Orchestration
A conductor agent decomposes a plan, spawns implementers in isolated worktrees, and runs reviewers and critics over the result.
Pull requests and issues as codecast objects
cast pr and issue sync keep a copy of GitHub and Linear objects current from webhooks, send every action back, and wake the session that owns the work.
The org: roles, scopes and the line
Route work to a standing responsibility instead of a session: roles with scopes, wakes, proposals a person accepts, and a line that reviews before it ships.
Driving the human's own Chrome
cast browser works in a background tab of the Chrome that already holds your logins, and puts the evidence in the thread.
Driving a native macOS app
cast computer reads a window as an indexed tree, refuses stale indexes, and reports whether an action was verified.
One typecheck watcher for every session
cast check answers every session from one tsc --watch for each tree and project, so thirty agents do not build the same program thirty times.
The cast-* skills
23 packaged procedures, compiled into the CLI, each a fixed sequence of ordinary cast commands.
Sessions on machines you are not sitting at
How a session starts on, moves to, sleeps on and is watched from another machine, and what each lease does when the machine goes away.
Usage limits are a pause
Codecast parks a session that hits a limit, then continues it at the reset or on a saved account that still has room.
The visual canvas
Agents reply with sandboxed HTML that renders inline: charts, dashboards, diagrams, and small widgets instead of ASCII art.
Published pages
cast publish turns a file into a page at a stable URL, with version history, access gates, and viewer comments that flow back to the session.
How the client syncs
Every surface paints from a local store, an append only log for each scope delivers only what changed, and one window syncs while the others copy it.