Documentation
Tracking and automation

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.

4 min read
Turn it on in Agent features

Orchestration hands a whole plan to one lead agent, and that agent runs a team. It starts an implementer for every task that is ready, has a reviewer check each one before it lands, and finishes with critics who look over the combined result. Several tasks move at once, and you follow the plan page instead of steering one conversation through every step.

It only starts when you ask for it.

A plan's Orchestration tab while agents work on it
The Orchestration tab: agents working, tasks done, and each task's status in order.

Turn it on

Open Agent features (under More in the sidebar), pick the computer your agents run on, and switch on Orchestration under Tracking & automation. It works with Claude Code. That computer does all the work, so a plan of many tasks keeps it busy for a while.

The Orchestration card in Agent features
Click How it works on the card for what it adds and a request to try.

Ask for it

Say it in the conversation, in your own words:

  • "Make a plan for the settings redesign, then orchestrate it."
  • "Orchestrate the webhook retries plan."
  • "Orchestrate the rest of the billing plan, two tasks at a time."
  • "Stop after the first wave so I can look at it."

If there is no plan yet, ask for one first and read it over. The plan is where you shape the work: its goal, its tasks and what depends on what.

How the work moves

Eight tasks in three waves. Each wave starts the moment the work it depends on is done.

In waves. Every task whose dependencies are done starts at once, each with its own implementer. As those finish, the next tasks unlock.

Each in its own copy. Every implementer works in a separate copy of your repository on its own branch, so agents running side by side never touch each other's files. Finished work merges back once it passes review.

A reviewer's verdict decides each task's path. After a few failed rounds, the lead agent asks you instead of looping.

Reviewed before it lands. A reviewer checks each finished task against what the task asked for and passes it, sends it back with notes, or rejects it. The lead agent tries a task a few times at most, then stops and asks you.

Critics look at the whole result, not single tasks. Serious findings go back in as a new wave.

A final sweep. Once every task has passed, critics review the combined code. Anything serious becomes new fix tasks and another wave. When they find nothing serious, the plan is done.

Follow it on the plan page

Open the plan. Its tasks move from Open to In Progress to Done as agents pick them up and finish, and the progress bar under the goal fills in.

  • Orchestration shows how many agents are working, how many tasks are done and any that are blocked, the Active Sessions with a link into each, and a Task Timeline with every task's status.
  • Graph draws what depends on what, so you can see which tasks are waiting on which.
  • Overview keeps the plan's timeline: progress at the end of each wave and the decisions the lead agent made, so the reasons survive the run.
A plan's Graph tab
The Graph tab: finished tasks, the ones running now, and the ones still waiting on them.

The lead agent's own conversation narrates each wave: what it started, what passed review, what it sent back. Message it at any point to change course.

When it needs you, you hear about it. A task the agents can't finish, a rejected review or a missing piece of context comes back as a question, and the lead's conversation is flagged in your inbox as needing you.

Orchestration or a workflow

Choose orchestration when the shape of the work isn't known up front and an agent should work it out. When the steps are known and must run the same way every time, with an approval at a fixed point, use a workflow.

When something is off

What you noticeWhat to do
The lead agent asks you about a taskAnswer in its conversation. It carries on with the rest of the plan meanwhile
Too many agents run at once for your machineTell the lead agent to run fewer tasks at a time
A task is stuck in progressOpen the task. Its sessions and activity show where it stopped. Ask the lead agent to retry or split it
The plan's tasks look wrong before it startsEdit the plan first, or ask for a new breakdown. Orchestrating a bad plan builds the wrong thing faster
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.
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.
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.
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