Changelog

What we shipped, month by month. Newest first.

July 2026v1.1.72 – v1.1.94Desktop v1.1.88Latest

Triggers, more agents, and published pages

This month codecast grew beyond a single agent. OpenCode and pi joined Claude Code, Codex, Cursor, and Gemini as first-class clients, with resume and forking to match. Triggers run follow-up work on a timer or a GitHub event and live in the inbox like sessions do. And `cast publish` turns any HTML file into a public page with a stable link.

Triggers: work that runs later

  • cast trigger add schedules follow-up work: once in 30 minutes, on a recurring interval, or when a GitHub event such as a PR comment lands.
  • Triggers live in the inbox next to your sessions. Each run links to the conversation it spawned, with a browseable run history on every surface.
  • Prompts are markdown, so a trigger can carry a full brief with goals and steps. --safe makes a run read-only.
  • Killing a session cancels its triggers; restoring the session re-arms them.
Deep dive: Triggers

OpenCode, pi, and Cursor

  • OpenCode and pi sessions record, resume, and fork like Claude Code and Codex ones, with thinking, images, and tool calls all rendered in place.
  • Cursor sessions resume through the agent's own resume path instead of restarting from scratch.
  • A client registry describes each agent once, so the next one is cheap to add. Failed turns surface as classified error banners instead of silent stalls.
  • Subagents nest under the session that spawned them, whichever client is running.

cast publish: pages from your terminal

  • cast publish report.html gives any HTML file a public page at a stable URL. Republishing the same file updates the same link.
  • Pages serve as branded documents with link previews, cached at the edge so they load fast anywhere.
Deep dive: Published pages

Owners, machines, and provider keys

  • Sessions now have owners separate from who started them. An agent-run session lands in a human's inbox, and a session can belong to several owners at once.
  • One header control assigns owners and the machine together, and cast spawn --device starts work on a specific machine.
  • A session moved between machines carries its uncommitted work along and posts a note about the checkout it woke up on.
  • Store a provider API key once and codecast injects it at launch on any of your devices, encrypted in transit and at rest.

The inbox, team-wide

  • Team mode shows every team-visible session on one board; keyboard navigation and the command palette follow the scope you are in.
  • Needs-input push notifications now come from the server, so your phone buzzes when a session waits on you and not before.
  • Session cards show which agent client is running, and questions with multiple answers render as real checkboxes.

Mobile catches up

  • A model and effort switcher in the session header, and a new-session sheet that matches web compose, machine picker included.
  • Inbox parity with the web sidebar: stash and kill buckets, project chips, and collapsible sections.
  • Canvas and full-message HTML rendering, and JetBrains Mono app-wide to match the web.

Hardened and faster

  • The daemon survives macOS sleep: the file watcher restarts if it goes deaf, and the watchdog no longer kills a healthy daemon on wake.
  • Device identity binds to the hardware, so a copied config directory can't impersonate its source machine.
  • Search falls back to title matches when content search times out, instead of returning nothing.
  • We closed unauthenticated cross-tenant access holes and cut hot-path query load across the backend.
June 2026v1.1.51 – v1.1.67Desktop v1.1.80

Messaging, comments, and cast blame

This month we built for teams working together. You can message any session like a colleague, leave comments on a teammate's work in a side rail, and trace any line of code back to the conversation that wrote it with `cast blame`. The inbox can favorite and file sessions, and the conversation viewer got density controls for skimming long histories.

Message any session

  • cast send reaches any session by its short id, old or active. A dormant session wakes up with full context and runs what you ask; a live one gets your note as a new turn.
  • The messaging snippet teaches this to your agents, so sessions talk to each other: one session hands another a task, asks it to report back, and acts on the reply.
  • Messaging routes team-wide. A session can message a teammate's session, with the sender's name on the message.
  • Paired with the stable feed, which injects recent team sessions into every new session at start, sessions have ambient awareness of each other: each one boots knowing which sessions exist, what state they are in, and how to reach them.
Deep dive: Messaging between sessionsDeep dive: Ambient awareness

cast blame: code that knows its origin

  • A drop-in replacement for git blame whose author column is the session, and person, that wrote each line.
  • Jump from any line to the conversation that produced it, scrolled to the exact edit.
  • Editor plugins for VS Code, Cursor, and vim-fugitive bring this inline, with a session log for any file.

Review and comments

  • Quote and comment on an assistant's reply in a right-hand rail; comments stay visible instead of hiding behind a hover.
  • Document review mode adds comments on individual diff lines.
  • A single message toolbar gathers quote, comment, copy, and thread actions in one place.

Organize the inbox

  • A Favorites view pins the sessions you keep coming back to at the top.
  • Manual labels and buckets let you file work under your own categories, in the app and from the CLI.
  • Stash sets a session aside without stopping its agent, separate from killing it outright.

Reading long conversations

  • Density modes (condensed, compact, and a summary view) collapse turns so you can skim a long session.
  • Large code blocks render faster, and scroll position holds steady when you switch sessions.
  • The command palette now searches across tasks, docs, and plans, not only sessions.

Faster and more reliable

  • Typing no longer drops frames in big session lists; the list is virtualized and view switches are deferred.
  • User messages don't get dropped; the send queue re-drives on reconnect, focus, and a timer.
  • Each message now records the model that produced it, and we cache agent status for faster loads.
May 2026v1.1.34 – v1.1.50Desktop v1.1.76

Run sessions on any machine

This month codecast started working across machines. Register a laptop, a cloud VM, or a throwaway sandbox, then send a session to whichever one has the code. You can move a running session between machines without losing context. We also spent the month hardening sync: catching stuck conversations, recovering wedged terminals, and making sure messages land.

Devices and remote sessions

  • A Devices settings page registers and manages your machines: Macs, cloud VMs, and on-demand sandboxes.
  • Move an active session from your laptop to the cloud, or between regions, mid-flight and without losing context.
  • The CLI runs an HTTP control server so the web dashboard can start, resume, and steer sessions on a remote machine.

Sync that recovers itself

  • cast status flags conversations that have stopped progressing, with a repair path to recover them.
  • Wedged-terminal detection forces a clean restart instead of retrying a dead session forever.
  • A delivery retry loop either lands your message or gives you a clear way to cancel, with no silent limbo.
  • Image-heavy conversations offload their images before syncing, so they stop getting stuck.

Inbox and triage

  • Each session card shows its terminal session and permission mode, so you can see why something is idle or waiting.
  • Permission-blocked agents show up in Needs Input instead of going unnoticed.
  • Task lists take a query filter for searching, and a new session links to its task as it's created.

Performance

  • Heavy libraries for diagrams, math, and graph rendering now load on demand, and we precompress assets, so pages load faster.
  • The conversation view no longer remounts when you switch sessions.
  • Your account, teams, members, favorites, and bookmarks moved into a local-first cache to cut re-fetches.
April 2026v1.1.21 – v1.1.32Desktop v1.1.64

Workspaces, windows, and shared documents

This month we added structure for bigger work. Group sessions, tasks, and docs into projects, open them in browser-style tabs, and tile several sessions side by side with the new window manager. Documents got wiki-style backlinks and public share pages. The CLI now encrypts the token it keeps on disk.

Projects and workspaces

  • Group sessions, tasks, and documents by project, and switch between projects inline.
  • Saved views remember a project-scoped slice of your work so you can return to it in one click.
  • Project detail pages show repositories, team suggestions, and recent activity.

Tabs and windows

  • A browser-style tab bar with keyboard shortcuts to open a session in a new tab, close it, and move between them.
  • A window manager brings multi-window support, so you can tile sessions side by side.
  • Tabs keep their conversation state alive when you switch away, instead of reloading from scratch.

Documents and sharing

  • Wiki-style backlinks and a sidebar tree turn documents into a navigable knowledge base.
  • Public share pages for documents and plans, with canonical URLs and copy-link buttons.
  • cast share and cast unshare publish a doc or plan to a public link from the terminal.

Teams and notifications

  • Per-teammate mute controls and notification-type toggles, so you only hear about what matters.
  • A single comment timeline on plans and docs, with delivery state for each message.
  • Team onboarding suggests repositories to connect and walks new members through setup.

Under the hood

  • The CLI now encrypts its auth token at rest with AES-256-GCM.
  • A local message cache loads conversations right away while fresh data syncs in the background.
  • An HTTP hook server pushes agent status to the web the moment it changes.
  • Desktop detects large and ultrawide displays and picks a sensible zoom level.
March 2026v1.0.48 – v1.1.7First 1.1 desktop builds

Plans, workflows, and orchestration

Our biggest month so far. We shipped plans and tasks to track multi-session work, workflows to chain agent steps and human approvals, and orchestration that runs a plan's tasks in parallel across agents. We rebuilt the web app on Vite, added a Cmd+K command palette, and shipped a collaborative document editor.

Plans, tasks, and orchestration

  • Plans capture multi-session features with goals and acceptance criteria; tasks carry priorities, status, and dependencies.
  • Orchestration breaks a plan into independent tasks and runs them in parallel waves across agents.
  • Failed tasks retry on their own with escalation logging; a dashboard shows what's in flight, blocked, or done.
  • The daemon links plans and tasks it sees referenced in conversations, so you don't track them by hand.
Deep dive: Tasks and plansDeep dive: Orchestration

Workflows

  • Graph-based templates that chain agent steps, shell commands, conditional branches, and human approval gates.
  • Run a workflow from the CLI, the command palette, or an @mention, with live progress in the dashboard.
  • Human gates pause and notify you; your reply flows into the next step's context.
Deep dive: Workflows

The web app, rebuilt on Vite

  • Moved off Next.js to Vite for faster builds and a cleaner desktop integration.
  • A Cmd+K command palette with full-text search across sessions, tasks, plans, and documents.
  • Native desktop notifications that click through to the session they're about.

Collaborative documents

  • A rich editor with @mentions, slash commands, images, and real-time multi-user sync.
  • Mention any session, task, plan, or doc inline and expand it into the page.
  • Promote a plan's body into a standalone document.

Activity, profiles, and subscriptions

  • Daily activity feeds with written summaries of what happened, grouped by project.
  • Profile pages with a 180-day activity heatmap and a timeline of your work.
  • Watch any session, plan, doc, or task and get notified when a teammate touches it.

Self-hosted backend

  • Moved the backend to self-hosted infrastructure with daily backups, cutting latency and cost.
  • Routed data access through one team-scoping layer to prevent cross-team leaks.
February 2026v1.0.31 – v1.0.45First desktop build · Mobile v1.0 (App Store)

Mobile, the inbox, and forking

This month we put codecast on more screens. The iOS app caught up to the web for reading and steering sessions, and the first desktop build went out. We added the inbox, one place that gathers every session waiting on you. Conversations can now branch, so you can try a different path without losing the original.

The inbox

  • One view of every idle and waiting session, ordered so the ones needing your input come first.
  • Defer and dismiss states with keyboard shortcuts to move through a queue quickly.
  • Pin important sessions so they stay reachable no matter how busy things get.

Mobile parity

  • Full chat rendering on iOS, including plans, tasks, skills, and tool calls.
  • Camera and photo picker, and jump-to-end navigation that matches the web.
  • Over-the-air updates ship fixes without waiting on an App Store review.

Forking conversations

  • Branch a conversation at any message into its own line, without touching the original.
  • A tree panel and branch selector let you navigate between forks.
  • Resume a branch as a fresh agent run, carrying the history up to the fork point.
Deep dive: Forks and spawned sessions

The stable feed: sessions that know their neighbors

  • cast stable injects a feed of recent sessions into every new session at start, so an agent begins already knowing what was just worked on.
  • Two scopes: solo injects your own recent sessions, team injects recent team activity with names attached.
  • Each feed entry carries the session's short id, so the agent can read any of them for detail with cast read.
  • Injection is a session-start hook with a timeout. If the fetch fails, the session simply starts without the feed.
Deep dive: Ambient awareness

Desktop debut and more agents

  • The first native desktop build, with a watchdog that keeps the daemon alive and restarts it on crash.
  • Gemini CLI sessions now record alongside Claude Code, Codex, and Cursor.
  • Remote commands let the web start, resume, kill, and switch sessions on your machine.
January 2026v1.0.2 – v1.0.26

Memory, teams, and reliable sync

This month we made past sessions useful. The CLI can search your whole history, answer questions about it, and pull up relevant prior work before you start something new. We added team sharing controls down to the individual message. GitHub commits and pull requests now flow into each session.

Agent memory in the CLI

  • cast search and cast feed find past work; cast ask answers natural-language questions over your whole history.
  • cast context pulls up the relevant prior sessions before you start something new.
  • cast handoff, cast summary, and cast decisions carry knowledge forward between sessions.
Deep dive: Agent memoryDeep dive: How agent snippets work

Teams and sharing

  • Belong to multiple teams and switch between them.
  • Choose what's visible to teammates, down to individual messages, plus auto-share folders.
  • Team profile pages, avatars, and live presence show who's active.

GitHub integration

  • Commits and pull requests flow in through webhooks in real time.
  • Each session collects the files it touched and the PRs it produced.
  • Per-repository scope lets teams choose which repos feed into codecast.

Reliable sync

  • A ledger tracks every message, with hourly reconciliation between your machine and the server.
  • A health command finds and repairs gaps before they become missing history.
  • The daemon starts on login and restarts itself if it stalls.
December 2025v1.0First release

The first release

This is the first release. We shipped a background daemon that watches your local session files and streams them to a shared backend as you work, plus a web dashboard to read them back. It works with Claude Code, Codex, and Cursor today.

The daemon

  • A background service that watches Claude Code, Codex, and Cursor session files and syncs them live.
  • A retry queue survives flaky connections so nothing is lost.
  • We redact API keys before anything leaves your machine, and hash project paths.

The web dashboard

  • Read full conversations with syntax-highlighted code, collapsible tool calls, images, and diffs.
  • Global search with instant filtering and highlighted snippets.
  • Shareable links to any conversation.

Foundations

  • Email and password accounts with protected routes.
  • Private-by-default conversations, with team sharing when you want it.
  • Project-based grouping and a virtualized message list that keeps even huge conversations fast.

Built to extend

  • A tool registry that can render any agent tool, with subagent conversations nested under their parent.
  • Token-usage tracking, and the warm light theme that sets the look of the app.

The first commit landed in December 2025.

Start capturing your sessions
One command. Works with Claude Code, Codex, Cursor, and Gemini.