Documentation
Tracking and automation

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.

4 min read
Turn it on in Agent features

When an agent takes on work that will run for a while, it files it where you can see it. A task is one piece of work: a feature, a bug, a chore. A plan groups several tasks under one goal. Agents create them, claim them, post progress as they go, and close each one with a line on what they checked. You follow it on the task and plan pages instead of scrolling back through conversations.

A plan with its goal, progress bar and four tasks
A plan an agent filed: one task done, one in progress with its session, two still open.

Turn it on

Open Agent features (under More in the sidebar), pick the computer your agents run on, and switch on Tasks & Plans under Tracking & automation. Do it on each computer you use.

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

What agents file, and what they don't

Agents use judgment here, not a rule that every request becomes a task:

  • A task when the work will outlive the conversation, needs a handoff, or should be tracked so you can check on it.
  • A plan when the work has several distinct parts that could run in separate sessions.
  • Nothing for questions, quick lookups and small fixes they will finish right away.

Before filing anything, an agent looks for an existing task or plan on the same topic and picks that up instead of making a duplicate.

Ask for it

  • "Break the billing rewrite into a plan with tasks we can split across sessions."
  • "File a task for the flaky webhook retry test and start on it."
  • "Pick up the next ready task in the webhook retries plan."
  • "What's left on the onboarding plan?"
  • "Mark the export task done, with what you verified."

The Tasks page

Click Tasks in the sidebar, under Work. It lists every task in your workspace. Switch between List and Board at the top, filter by status, priority, label or assignee, and click Add task to file one yourself. Work filed in a team shows to that team; work you file privately stays yours.

The Tasks page as a board
The Board view: tasks in columns by status, each with its assignee.

A task's page

Click a task to open it. Its status moves through Backlog, Open, In Progress, In Review and Done, with Dropped for work that won't happen. Change the status, priority and assignee yourself from the row at the top.

A finished task with its evidence, session, plan and activity
A task an agent closed, with what it verified and the session that did the work.
  • Session shows the session working on the task, and you can read it and answer it right there. With no session yet, click Hand to an agent to start one.
  • Evidence is what the agent says it verified when it marked the task done. Agents are told to close only work they actually checked.
  • Sessions (or Other sessions, when one is working on it now) links every conversation that worked on the task.
  • Plan links the plan the task belongs to.
  • Blocks and Blocked by show what has to finish first. A task waiting on another doesn't show as ready until that one is done.
  • Activity is the running log: status changes and the agent's progress notes.
  • Leave a comment at the bottom. When a session is working on the task, the comment also goes to that session (Also sends to this session), so you can steer the work from the task page.

A plan's page

Open Plans from the command palette, or click the plan named on any of its tasks. The goal sits under the title, with a progress bar across all its tasks, and four tabs:

  • Overview lists the tasks and the plan's timeline. Decisions an agent makes along the way land here, so the reasons survive after the conversations end.
  • Orchestration shows which agents are working which tasks right now (Orchestration).
  • Board lays the tasks out by status.
  • Graph draws what depends on what.

On your phone

The Tasks tab in the iPhone app has Tasks, Plans, Docs and Triggers. Open a task to see its status, plan, blockers and activity, and add a comment; open a plan to see its tasks.

The Tasks tab on the iPhone app
The Tasks tab on the phone, with open tasks at the top.

When an agent needs you

If an agent gets stuck, it says so instead of going quiet: blocked on something only you can provide, missing context, or finished with a concern you should look at. The conversation is flagged in your inbox as needing you, and the reason sits on the task.

Where this leads

Tasks and plans are what the rest of the tracking tools hang on. Orchestration runs a whole plan across many agents at once. Workflows run a fixed sequence of steps against a task, with approval gates. Triggers come back to a task later or on a schedule.

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.
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