Documentation
Working together

Pinned thread state

The agent keeps one short note on each session saying where it stands, above the composer and on its inbox card.

4 min read
Turn it on in Agent features

A long session is hard to walk back into. The transcript holds everything the agent did, in order, which is the wrong shape for the question you have when you open it: where does this stand right now?

With Thread State on, the agent keeps one short note pinned to the session that answers that question: what it is working on, where things stand, what comes next, and whether anything is yours to decide. It rewrites the note as the work moves and clears it when it stops being true. You see it above the composer the moment you open the session, and on the session's inbox card before you open anything.

The pinned state above the composer: a Needs you chip and the headline on one line, then a You line on amber, a Done checklist and a Next line
A pinned state in a conversation. The chip says who acts next, the headline says where the work stands, and the You line is what the agent needs from you.

Turn it on

Open Agent features (under More in the sidebar), pick the computer your agents run on, and switch on Thread State in the Context group. Sessions that start after that keep a pinned state. Click the card for what you'll see and a request to try.

You don't need to ask for it once it is on, but you can steer it:

  • "Keep your thread state current while you work through this refactor."
  • "Put the open question about the API key in your pinned state."
  • "Clear your pinned state, the work is done."

What you see

In the conversation, the note sits in a panel just above the composer:

  • The header is the answer: a status chip (In progress, Needs you, Complete or Dormant) and the headline, one line on where the work stands. A note without a status shows Pinned.
  • On the right, how old it is, such as 4m. Once the thread has run well past the note, it turns yellow, and when messages are why, it counts them: 4h · 64 new messages.
  • Under the header, each detail line sits beside its label. You is what the agent needs from you, on amber, with a Copy button when it is a command. Done is a checklist of what is finished, and Next says what happens next and when. A long note folds to Show all.
  • Click the header to collapse the panel to the headline. The × that appears on hover clears the note; a toast reads Pinned state cleared with Undo.

On the inbox card, the note replaces the generated summary with one line: what the agent needs from you when there is something, otherwise the headline. A small pin marks it, colored by status, and a chip names a blocked, done or dormant session so you can scan the inbox without opening anything. The phone's inbox shows the same line.

Inbox cards with pinned lines: one under Needs You asking for a staging API key, one under Working on webhook retry backoff
The pinned line on inbox cards, colored by status.

Who acts next

The status on the note decides where the session files in your inbox when the agent's turn ends.

The status the agent pins decides the inbox section. A turn that says nothing files under Needs You, so you open it and find out.
  • Needs you is the one status that asks for you. It brings a stashed session back to the inbox, so agents use it only when they truly can't continue without you. A question that can wait goes to your decision queue instead.
  • Complete and Dormant cover only the turn that set them. A dormant note says what will wake the session: a schedule, a background job, a reply from another session.
  • When you send the session a message, the note comes down, because you have answered it. The agent pins a fresh one when its turn ends. A message from another session or a scheduled wake leaves the note standing.

A note that has gone stale says so

Nothing forces an agent to keep the note current, so codecast never pretends it is. Every note shows how far the thread has moved since it was written, and the panel changes as that gap grows.

Fresh, aging, then hidden, by messages or by hours, whichever comes first.

For its first 60 messages the note is fresh. After that its age turns yellow and the header counts the messages since. At 200 messages it is hidden everywhere, because a line the thread has run far past is worse than no line. Time counts too, more gently: a session parked overnight on a long test run hasn't changed, so the clock only ages a note after 12 hours and hides it after 48. Each rewrite starts both counts again.

When something is off

What you noticeWhat to do
No pinned state on new sessionsCheck that Thread State is on for the computer the session runs on, in Agent features. Sessions already running when you switched it on don't pick it up
The note says the agent is waiting on something that already happenedTell the agent. It rewrites the note when it ends that turn
A session sits in Needs You but needed nothingThe agent ended its turn without saying who acts next. Ask it to keep its pinned state current
You cleared a note by mistakeClick Undo on the toast, or ask the agent to pin it again
More guides
Agent features: what your agents know how to do
Switch features on for each computer, and every new session there learns to remember, delegate, track work, show results and use your machine.
Memory: agents that look up past work
Your agents search every session you can see, across your machines, agents and team, and answer with the session they found it in.
Search your history across every machine
Every computer you connect sends its sessions to one history, searchable from the web, the Mac app and your iPhone.
See which agent session wrote a line
Set Blame to Sessions on any file to see the session behind each line, and open the conversation where it was decided.
Messaging between sessions
Your sessions hand each other results and answers directly, so you stop relaying text between them.
Stable context: sessions that know what's been happening
New sessions start with a short list of what you and your team worked on recently, so they pick up threads instead of starting cold.
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.
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.
Tasks and plans
Agents file the work they take on, post progress and close it with what they verified, and you follow it on the Tasks and Plans pages.
Triggers
Agents schedule their own follow-ups, once, on a schedule or on a GitHub or Linear event, and you can set one yourself from the Triggers page.
Workflows
A fixed sequence of agent steps, checks and approval gates that runs the same way every time and waits for you where you want a say.
Orchestration
Hand an agent a whole plan and it runs a team: implementers working in parallel, a reviewer on every task and critics on the result.
Pull requests and issues
Every pull request gets a page with its checks and threads, the session that opened it fixes what reviewers and CI flag, and Linear or GitHub issues become tasks.
The org: roles that look after your work
Give lasting work to a role with an area, a charter and a standing session, and approve the changes your agents propose to the org.
Let agents use your Chrome
Agents check pages in the Chrome you already use, logins included, from their own background tabs. Screenshots and errors come back to the conversation.
Vault: keys, logins and sign-ins for your agents
Fill a credential once and every agent on every machine can use it, without the value ever entering a conversation.
Computer use: agents in your Mac apps
Agents work in Preview, Slack, System Settings or your own desktop build, in the background, with an orange pointer that shows where they act.
Typecheck: one shared check for every agent
With Typecheck on, agents on a computer share one typecheck per project, so checks answer in seconds and a busy machine stays usable.
Skills: slash commands for the jobs you repeat
Type / in a Claude Code session to pick up work, hand it over, get a second opinion or ship a pull request, the same careful way every time.
Run sessions on other machines and in the cloud
Start a session on another computer or a cloud machine in your AWS account, move it there and back, and watch it from anywhere.
Codex Cloud tasks in codecast
Bring your Codex Cloud tasks into your inbox, start new ones with several attempts, and turn the result into a pull request or local changes.
Usage limits are a pause
When a Claude plan runs out, sessions wait for the reset or continue on another account you've saved, instead of stopping for good.
The visual canvas
Agents answer with charts, comparisons and diagrams drawn right in the conversation when a picture says it better than text.
Published pages
Agents turn reports and mockups into pages with their own link that you can share, gate, and get comments on.
Why codecast feels instant, even offline
Everything you see comes from a copy on your device that the server keeps current, so screens open at once, your edits show immediately, and nothing is lost offline.
Taking longer than usualOffline · reloads when back