Documentation
Collaboration

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.

$cast install stable

Stable mode injects a feed of recent sessions into every new session at start. The agent's first context window already contains what the team worked on recently: session IDs, titles, work states, message counts, and the opening lines of each conversation. Paired with messaging, this gives a fleet of sessions ambient awareness of each other — every session knows its neighbors exist, what state they are in, and how to reach them.

Stable mode is enabled through the snippet system's wizard, or directly:

cast install stable      # enable (solo)
cast stable team         # switch mode
cast install stable --disable

Solo, team, off

Stable is a three-way choice, not a toggle:

ModeFeed contentsLookbackItems
soloyour recent sessions in this project7 days10
teamall team-visible sessions in this project14 days15
offnothing injected——

A global flag widens the feed from the current project to everything you can see. In team mode the feed includes teammates' sessions with their names attached, so a fresh session starts knowing that a colleague's agent is mid-flight on the same subsystem — before it duplicates the work.

How injection works

There are two injection paths, one per agent family, sharing a single builder so the feed parameters and format can never drift:

  • Claude Code: cast install stable registers cast stable-context as a SessionStart hook. When a session boots, the hook fetches the feed and prints a <stable-context> block that Claude Code folds into the opening context.
  • Codex: the daemon builds the same block and passes it as developer instructions when it spawns the thread.

The injected block looks like this:

<stable-context mode="team">
This gives you bigger-picture visibility on what has been and is
being worked on by the team.

── Session binding Convex error ────────────────────
   jx7az96 | ● needs input | 41 min ago | 408 msgs | ~/src/codecast
     1: [user] …first line of the conversation…
     2: [assistant] …first reply…
…
Use: cast read jx7az96 <range>    # read messages by line range
</stable-context>

Each entry carries the session's short ID, so the agent can immediately cast read any of them for detail — or cast send one a message. The feed is oriented toward action, not decoration: "needs input" means the ball is in someone's court, "working" means an agent is mid-flight, and the agent reading the feed is expected to use that.

Recorded, visible, failure-safe

What was injected is recorded against the conversation, and the web renders it as cards at the top of the transcript — so a human reading the session later sees exactly which sessions the agent knew about at boot.

Injection is an enhancement, never a boot blocker. The fetch has a hard timeout, and any failure — network down, backend unhealthy, not authenticated — means the session simply starts without the block. Specific sessions can be excluded from the feed (the daemon uses this to keep a spawned worker from seeing its own siblings' noise when that would mislead it), and the fetch over-fetches by the exclusion count so the feed never shrinks below its normal size.

Why this changes fleet behavior

Without stable mode, a session knows only what its prompt says. Coordination has to be pushed: someone (human or orchestrator) must tell each worker about the others. With stable mode, coordination can be pulled: any session can notice a neighbor in the feed, read its transcript, and message it. The messaging guide shows the patterns this enables — delegation, peer collaboration, and fleets where workers find each other by label. Awareness comes from the feed; action comes from cast send.

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.
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.
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.
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.