Documentation
Working together

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.

5 min read
Turn it on in Agent features

When an agent reaches a choice only you can make, it has two bad options. It can stop and ask, which pulls you out of your own work to read a transcript. Or it can pick alone, and you find out after code depends on the pick.

With the Decision queue on, the agent writes one clear question, the options with what each one costs, and its reasoning. The question waits on the Decisions page until you get to it. You answer with a click or a number key, and the answer goes back to the session that asked as an ordinary message. The agent carries on from there.

A session waiting on a decision: the question in large type, the agent's reasoning, numbered options each with its consequence, and a field to answer in your own words
A session waiting on your decision, with everything you need to answer on the card.

Because a queued question costs you little, agents are told to ask more often than they would interrupt you. A choice they would otherwise have made silently and mentioned in passing goes to the queue.

Turn it on

Open Settings, pick Agent Features under Machines, choose the computer your agents run on, and switch on Decision queue under Working together. How it works on the card shows an example.

Agents ask on their own once it is on. You can also tell them when to:

  • "If you need my call on the caching strategy, queue a decision and keep going on the rest."
  • "Before you pick a database for this, ask me with the options laid out."
  • "Put the three layout options in front of me as a decision, with a page for each."

The Decisions page

Decisions in the sidebar carries a count of the questions waiting on you. It opens a list: Mine for what you own, Team for the whole team's, plus Unassigned, Escalated and Answered. Filter by owner, area, kind or how long a question has waited, and switch between List and Cards.

The Decisions page: a list of open questions from Acme's sessions, with Mine selected and counts on each tab
The Decisions page, with three questions waiting on you.

Click a row to open the decision's own page: the question, the agent's full reasoning or the report it attached, a page per option when the agent made one, a discussion, and the answer controls. The arrows at the top, or the arrow keys, flip to the next and previous decision.

Answer one at a time

One at a time walks the queue as full cards, each on the asking session's pane, so you can clear it in one sitting.

One decision shown full screen, with its options numbered and the key hints for skip, dismiss and open the session
Working through the queue one decision at a time.
KeyWhat it does
1 to 9Answer with that option
tOr answer in your own words: your text goes to the agent as a message
sSkip for now
xDismiss. The question leaves the queue and the agent is not told
oOpen the session
escLeave the queue

The order follows a rule. Questions holding an agent up come first, then questions from sessions that have stopped, then questions the agent is already working around. Inside each group the oldest comes first. Each card shows its age in time and in messages since it was asked, so a question the thread has moved past is easy to spot.

A permission prompt or a question an agent asked in its own terminal shows under Waiting in a terminal. You answer those in the session itself, with its real approve and deny controls; number keys never approve anything.

In the conversation

Opening a session that is waiting on you shows the decision as a full card, headed Waiting on your decision. Answer it there, share it with the share button, or click Read the thread to fold it away and see what led up to it.

After you answer, the transcript keeps the record: the question marked answered with a check on your choice, and your answer as a message linked back to the ask.

The answered decision in the transcript: the chosen option checked, the answer as a message, and the agent's reply
The same decision after answering, with the agent's next step below it.

Some questions don't need to hold the agent up. When the agent has a sensible default that is cheap to undo, it keeps working on it and the question docks above the message box with its options, a field to Answer in your own words, and Open for the whole question. Your answer can still override the default. Agents are told to wait instead whenever undoing the default would cost more than waiting.

A question docked above the message box while the agent keeps working, with two option buttons, an answer field and Open
A question the agent is working around, docked above the message box.

When a message names several open decisions, a bar above it counts them, and Go through them opens exactly those as full pages you flip through.

On your phone

In the iPhone app, a to decide badge beside the Inbox title shows the count and opens Decisions, with Mine and Team and Answer one at a time. Each card has its options, Dismiss and Skip, and moves to the next when you answer.

The iPhone decision card with the question, two options and Dismiss and Skip at the bottom
A decision on the iPhone.

Stacks

When several decisions belong together, such as a launch checklist, switch the Decisions page to Cards, click group into a stack, tick the cards, name the stack and click create the stack. On the stack's page you can set a Due date and an Auto default: after that many hours, any question the agent was already working around is answered with its default. Questions holding an agent up are never answered for you.

What agents are told

  • One question per decision, with the reasoning written so you can answer without opening the session.
  • Ask before choices that are hard to reverse, that spend money, that touch production or user data, or that come down to taste.
  • Never ask what reading more code would answer, and never use the queue for status updates.
  • Keep the ask correct: edit the open question when the facts change, and withdraw it when it no longer matters. A withdrawn question shows as withdrawn in the conversation.
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.
Let Claude, Cursor and Codex read your codecast
Add codecast.sh/mcp to an agent that runs outside codecast, sign in once, and it reads your docs, tasks, plans, pages and sessions as you, read only.
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.
Pinned thread state
The agent keeps one short note on each session saying where it stands, above the composer and on its inbox card.
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