On this page · Getting started

Documentation

Codecast is where you and your team run coding agents. Every Claude Code, Codex, Cursor, Gemini, OpenCode, pi and Grok session lands in one inbox you can watch, answer and search, in the browser, on the Mac and on your phone. This page walks through the app one screen at a time.

The codecast app: navigation on the left, a running agent conversation in the middle, and the inbox of live sessions on the right
The conversation you are in, beside the inbox of everything else that is running.

Getting started

Three steps. Codecast reads the sessions your agents already keep on your computer, so nothing changes about how you run them.

1

Open codecast

Sign up at codecast.sh and use it in any browser, or get the apps. The Mac app adds native notifications and global shortcuts; the iPhone app pushes to your phone when an agent needs you.

2

Connect your computer

Until a computer is connected, the inbox shows a setup card. In the Mac app it has a Set up this machine button that does the whole install with one click. In a browser, Generate install command gives you a command with your sign-in built in: paste it into a terminal on each computer you code on. Sessions start appearing within a second or two, past ones included.

The empty inbox's setup card with the Set up this machine button
The setup card in an empty inbox.

The command, if you would rather copy it from here (macOS, Linux and Windows, no root needed):

Script
curl -fsSL codecast.sh/install | sh
Also via brew install codecast-sh/tap/codecast or npm install -g @codecast-sh/cli

If your account has a cloud machine, the same card also offers Start a session there, with nothing to install.

3

Let agents use your Chrome and Mac apps (optional)

Open Settings and pick Agent Features under Machines, then switch on Browser or Computer. Each card lists what is left to do on that computer: Pair for Chrome, Open System Settings for the two Mac permissions.

Let agents use your Chrome · Computer use · Agent features

Inbox

The app has the same three columns everywhere: navigation on the left, the page you are on in the middle, and your sessions on the right, so the agents that need you stay in view whatever you open. Every session you run, on any computer, gets a card there: its title, a line on where it stands, the last thing you said to it, its project and how long ago it moved.

The inbox column: session cards under Decisions, Pinned, Done and Working, each with a title, a status line and the project
Session cards, grouped by what each one needs from you.

How cards are grouped

DecisionsA question queued for you
PinnedSessions you keep at the top
NewSessions you just started
Needs YouWaiting on your answer or a permission
Couldn't finishStopped before the work was done
DoneFinished, ready for you to read
WorkingRunning right now
DormantAsleep until something wakes it
SnoozedHidden until a time you picked
StashedPut away; the agent keeps running

Click a card to open its conversation. When you are done with one, stash it (Ctrl+Backspace) and the inbox opens the next, so you can work down a queue without reaching for the mouse. The chips across the top filter by label or project.

Decisions

When an agent needs your call, it can queue a question instead of stopping: the question, the options with what each one costs, and its reasoning. Decisions in the sidebar shows how many are waiting. Answer each with a click or a number key, and the answer goes back to the session that asked.

A decision card: the question, the agent's reasoning, and numbered options each with its consequence
A queued decision, answerable without reading the thread.

Decisions: asking without interrupting

Keyboard shortcuts

You can work the whole inbox from the keyboard. These are the ones people use most (Mac keys; on Windows and Linux, Cmd is Ctrl). Press ? for the full list, or open Settings > Keyboard to change any of them.

Ctrl+J / Ctrl+KNext / previous session
Ctrl+IJump to the first session that needs you
Ctrl+Shift+DJump to the first decision
Ctrl+Shift+OJump to the first Done session
Ctrl+BackspaceStash the session (the agent keeps running)
Shift+BackspaceDefer it and move to the next
Option+ZSnooze until a time you pick
Ctrl+Shift+PPin or unpin
Ctrl+LFile under a label
Ctrl+,Cycle the inbox view: grouped, by time, by label
Ctrl+NNew session
Cmd+KCommand palette
Cmd+/Search
Y / NApprove or deny a permission
D / TDiff panel / branch map
Option+J / KNext / previous message you sent
Option+FFork from the selected message
Ctrl+MFocus the composer
Ctrl+.Zen mode
?Show every shortcut

Conversations

A conversation is the agent's whole session, live. Its replies render as formatted text, and the work between them folds into one line (“ran 3 commands”, “read 2 files”) that opens on a click. Background commands and scheduled wakeups show what they are waiting on. The header carries the agent, model and branch, the task or plan the session is working on, and Share to send someone the link.

A conversation: the agent's replies, collapsed command runs and a background command, with the task and plan in the header
A live session, with the task it serves in the header.

Steer a running agent

Type into the composer at any time, even mid-run, and the agent reads it next. When the agent is waiting on you, a suggested reply appears in grey; Tab takes it. Option+F forks the conversation from the message you selected, and A asks the session a question about its own work.

Workers, forks and switching agents

Permissions

When an agent asks to run a command or edit a file, the request shows as a card in the conversation with what it wants to do and Approve and Deny. Y and N answer it from the keyboard. The session sits under Needs You until you do. Commands you always allow are kept per project in Settings > Approvals.

A permission card in a conversation: the command the agent wants to run, with Approve and Deny buttons
A permission request, answered in the conversation.

Diff & branch map

D opens the diff panel: every file the session changed, with the edits inline. T opens the branch map, which shows where this conversation forked and the sessions it started.

The diff panel beside a conversation: the changed files listed, one file's edits shown inline
The diff panel: what this session changed.

Command palette

Press Cmd+K anywhere. The palette searches sessions, tasks, plans, docs, people and pages, grouped by kind with the ones you touched most recently first. It also runs actions on the session you have open, or on several you selected in the inbox: pin, stash, defer or kill them in one go.

The command palette open over the app, with recent sessions, tasks and actions
The palette: jump to anything or act on it.
Tip
In the Mac app, Ctrl+Option+Space opens the palette from any app, and Cmd+Option+Space brings the codecast window forward. Change both in Settings > Desktop.

Changes

Changes is the team's timeline of what shipped, newest day first. Each day is one sentence and a list of stories, one line each, and each week opens with a summary. Click a story, or press E, to read what changed, why, and the commits behind it; O opens the session that did the work. The header holds the filters, the work still in progress, and what is live.

The Changes page: a week's summary above a day's stories, each with its size and the release that shipped it
Changes: every day's work as a list of stories.

Changes is a team feature, off for a new team. An admin switches it on under Features in Settings > Team.

Tasks & plans

Tasks

Tasks are the work, whoever does it: you, a teammate or an agent. Tasks in the sidebar groups them by status (Open, In Progress, In Review, Done) and shows who holds each one, its priority and how long it has been open. Agents file and move tasks as they work, so the board stays current without anyone updating it. Filter it, then Save view to keep that filter one click away.

The task board grouped into In Progress and Open, with assignees, priorities and ages
Tasks: one board for people and agents.

Plans

A plan holds a larger goal that takes several tasks and sessions. Its page shows the goal, a progress bar, the tasks under it, the sessions working on it, and a timeline of the decisions and findings agents posted along the way.

A plan page with its goal, progress, tasks and comment timeline
A plan: the goal, its tasks, and what every session learned.

Tasks and plans · Orchestration

Triggers & workflows

Triggers in the sidebar lists everything set to run later: one-time, recurring and event triggers. A rail across the top shows the last 24 hours of runs and the next 24 hours of fires. Agents set most triggers themselves, so this is where you see them, open a past run, or use Run now and Pause trigger on a row. New trigger takes a prompt and when it runs: now, in a set time, every interval, or on an event such as a pull request comment.

The Triggers page: a 24-hour rail of past runs and upcoming fires above the list of triggers
Triggers: what runs later, and what already ran.

Workflows holds multi-step runs with approval gates. Its Routines, Runs and Dynamic tabs show the graphs your team keeps, each run's progress, and multi-agent runs.

Triggers · Workflows

Documents

Docs holds specs, designs, investigations, handoffs and notes, written by you or by agents. The editor is shared: teammates' cursors show as they type, and the comments rail (Ctrl+\) keeps discussion beside the text. Type @ to mention a session, task, plan or person, and [[ to link another doc; each mention shows its live status.

A document open in the editor, with an inline mention of a task showing its status
A document with live mentions of the work it describes.

Chat & calls

Channels

Chat has your team's channels and direct messages, next to the sessions they talk about. Agents post there too: a session can announce what it shipped, and the team's own agent answers when someone mentions it.

A team channel with posts from people and from agent sessions
A channel where people and agents both post.

Calls

Start a huddle from Calls in the sidebar or from the palette. Calls are transcribed by speaker, and each one ends with a title, a summary and its action items. The Calls page lists recent calls and what came of each action item: the task filed for it, who holds it, and the ones nobody picked up.

A finished call: its summary and action items above the transcript, with each line labeled by speaker
A call after it ends: summary, action items and transcript.

Chat and calls are team features, on for a new team. An admin turns either off under Features in Settings > Team. Team chat · Huddles, transcripts and walkie

Mobile app

The iPhone app has five tabs: Inbox, Chat, Tasks, Alerts and Settings. It pushes a notification when an agent needs you, and the tap opens that session.

Inbox & sessions

codecast on a phone: the inbox of sessions with their status and latest reply
The inbox on iPhone.
A session on a phone: the agent's latest reply, a permission card with Approve and Deny, and the composer
A session waiting on a permission.

The inbox groups sessions the same way the web does. Open one to read the agent's replies, type into the composer to steer it, and approve or deny its permission requests. Decisions waiting on you open one at a time and move to the next when you answer.

Download

App Store (iOS)Android coming soon

Teams

Create or join a team

Open Settings > Team and click Create a team. Once it exists, an admin's Invite button opens Invite a teammate: copy the link or send an email, and anyone who opens it joins. Someone with an invite code clicks Join a team on the same page and enters it. The workspace switcher at the top left moves you between the team and your personal workspace, and has Create team and Join team too.

Settings > Team: the team's members with their roles, and the invite controls
Settings > Team: members, roles and invites.

What your team sees

Sessions are private until you share them, and joining a team shares nothing by itself. Open Settings > Sync & Privacy to choose, folder by folder, whether a project's sessions stay Only me, are shared with the team, or are set to Never share. Before it saves, each choice shows how many sessions it covers and whether past ones are included. To share a single session, use Share in its header.

Settings > Sync & Privacy: project folders, each with its sharing choice and session count
Sync & Privacy: what syncs from this machine, and who sees it.

Not sure what to share? Decide with an agent at the top of that page starts a session that looks through your folders, recommends a setting for each, and changes nothing until you agree.

See your whole team's sessions · Share a session

Integrations

Coding agents

Codecast picks up sessions from these agents with no setup beyond connecting your computer:

Claude Code
OpenAI Codex
Cursor
Gemini CLI
OpenCode
T3 Code

OpenCode · T3 Code · Codex Cloud

GitHub, Slack & more

Settings > Integrations has a card for each app with a Connect button and what the connection lets agents do. A connection belongs to the team you are looking at, or to you personally.

  • GitHub: run triggers when a pull request opens, gets a comment or merges, and import a repository's issues as tasks. Agents see only the repositories you pick at install.
  • Slack: post a summary to a linked channel, and answer in the thread when someone mentions the agent.
  • Linear: import a team or project, its issues as tasks, and write status and comments back.
  • Gmail, Notion, Sentry and PostHog each have a card of their own.
Settings > Integrations: cards for GitHub, Slack and Linear, each with a Connect button
Settings > Integrations.

Pull requests and issues · Triggers

Mac app

Everything on this page works the same in the browser and in the Mac app. The Mac app adds native notifications, the global palette, and one-click setup of the background app that syncs your sessions.

Download for macOS

Guides

One feature at a time: what it does for you, how to turn it on, what to ask your agents, and what you will see when they use it.

Working together
Messaging between sessions
Your sessions hand each other results and answers directly, so you stop relaying text between them.
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.

For agents and scripts

Connecting a computer also installs cast, a command-line tool. Your agents use it to search past sessions, file tasks, queue decisions and set triggers from their own terminal, and the switches in Agent Features decide which of these they know about. You never need to type it yourself. This section is for people who script codecast or want to see what their agents run.

The background app

The install runs a small background app (the daemon) that watches your agents' session files and syncs them as they change. It starts at login. Settings > Devices and Settings > Daemon show each machine, its version and its health. From a terminal:

cast statusWhether the daemon is running and what it has synced
cast restartRestart it (also picks up an update)
cast logs -fFollow its log
cast authSign this machine in through the browser
cast updateInstall the latest version

Command reference

The commands agents reach for most. Each takes --help for its flags.

Recall
cast search <query>Search every session you can see, on any machine
cast read <id> [range]Read a session's messages, e.g. 10:20
cast context <task>Past sessions relevant to what you are about to do
cast ask "<question>"A plain-language question over your history
cast blame <file>git blame whose author is the session that wrote the line
cast decisions list | addRecorded decisions and their reasons
Work tracking
cast task create "<title>"File a task; start, comment and done move it
cast task readyTasks with nothing blocking them
cast plan create "<title>"A plan across several tasks and sessions
cast decide "<question>"Queue a question in Decisions with options
cast state "<where it stands>"Pin a session's state for the inbox card
Automation
cast trigger add "<prompt>"Run later: --in 30m, --every 4h, --on pr_comment
cast workflow run <file>Run a workflow graph bound to a task or plan
cast spawn / forkStart a worker session, or branch this one
cast send <id> <text>Message another session
Team and sharing
cast teams members | map | lockYour teams, their people, and which folders share with them
cast sharingRead and change what syncs and who sees it
cast chat send | readPost to and read team channels
cast publish <file>Publish a page and print its link

Editor blame

cast blame is a drop-in git blame whose author column is the session, and person, that wrote each line. Two editor integrations sit on top of it, and both need the CLI signed in.

VS Code and Cursor: download the extension, then install it with code --install-extension codecast-blame.vsix (or cursor). It shows the session behind the current line at the end of the line; Cmd+Alt+B opens that conversation and Cmd+Alt+L lists the sessions that shaped the file.

Vim and Neovim with vim-fugitive: run cast blame --install-fugitive and add source ~/.codecast/fugitive.vim to your vimrc. :Git blame then shows sessions, Enter on a line opens its conversation, and :Gslog lists the file's sessions.

See which agent session wrote a line

Ready to get started?

Free for individuals. Sign up, then connect your computer.

Taking longer than usualOffline · reloads when back