Documentation
Agent features

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.

6 min read

Your coding agents don't know codecast exists until something tells them. Agent features is where you decide what they learn: to look up what earlier sessions decided, hand work to another session, track work on your board, show results as charts and pages, or use your browser and your Mac. Each feature is a short set of instructions added to the agent's own setup on one computer. Switch it on and every new session there knows how to use it.

Nothing runs because a feature is on. A feature teaches an agent what it can do; the agent reaches for it when the work calls for it, or when you ask.

Find it

In the sidebar, open More and choose Agent features. In the Classic style it is in your account menu instead. You need at least one computer connected to codecast; Getting started covers that.

The top of Agent features: the machine picker set to this computer, Find a feature, All, On and Off, and the count of features on
Agent features shows one computer at a time, with a count of what is on there.

The page shows one computer at a time. Pick it from the machine picker at the top; the one you are on is marked this computer. Each machine keeps its own setup, so a feature you turn on for your laptop is not on your cloud host until you turn it on there too. A machine that is offline is marked Offline and its switches are disabled until it reconnects.

The page

Features are grouped by what you get from them:

GroupWhat's in it
ContextWhat an agent knows before it starts: past sessions, and where each thread stands
Working togetherSessions that delegate, message each other, and bring you a decision instead of an interruption
Tracking & automationTasks and plans on your board, runs that fire later or on events, and pull requests seen through to merge
Showing the workVisuals in the conversation, pages you can share, and mods that extend the app
Hands on the machineYour browser, native apps and simulators, plus the shared typecheck and usage limit recovery
The Context group: Stable context, Memory and Thread State cards, each with a picture, a switch and a one-line summary
Each card shows what the feature looks like in use, its switch, and what you get. Click a card for How it works.
  • The switch on each card turns the feature on or off for the selected machine. Turning one on first shows what it adds to that machine and asks you to confirm; turning it off is one press. The change applies within seconds.
  • Review all, at the top of a group with more than one feature off, lists what would switch on and asks you to confirm.
  • Find a feature searches names and descriptions. All, On and Off filter the list, and the count at the right says how many are on for this machine. On a wide window the group list on the left jumps to a group and shows its count.
  • Stable context is the one feature with three settings instead of a switch: Solo starts each new session with your 10 most recent sessions from the last 7 days, Team with the team's 15 most recent from the last 14 days, and Off with nothing. All projects applies it everywhere rather than per project.

How it works, for each feature

Click any card to open its detail: What you'll see once it is on, When agents use it, and Try asking with a request to send. Many link straight to the place in the app the feature feeds, such as Tasks, Triggers or Pages, and to the full tour of the feature.

The Memory detail: its switch, What you'll see, When agents use it, Try asking, and Read exactly what your agent reads folded at the bottom
A feature's detail, opened from its card.

At the bottom, Read exactly what your agent reads unfolds the full text the feature adds to your agent's setup. There is no hidden prompt: what you read there is what your agent reads.

Features that need a one-time step on the machine, like Browser (pair the Chrome extension) and Computer (two macOS permissions), show that step right on the card and in the detail as soon as you switch them on.

New features

When codecast ships a feature after you joined, a slim banner naming it appears above your tabs. Click See what's new to open New agent features, which describes each one and what it writes, and click Turn on… to review and switch it on for every machine that is online. Turning one on or dismissing it hides the banner for that feature for good; Agent features stays the place to change your mind. New features also carry a New pill on their card for a while.

The New agent features window, listing one new feature with Turn on… beside it
New agent features, opened from the banner.

What changes on your machine

  • Your agents' own instruction files, and nothing else. Claude Code reads its instructions from a file in your home folder, and so do Codex and Grok. A feature adds one clearly marked section to each of those files that exists on the machine. Agents with no such file get nothing, so codecast never writes files no agent reads.
  • Never your repositories. Codecast doesn't touch the instruction files inside your projects. Every project gets the features, and your repos stay clean.
  • Your own text is safe. Codecast only ever replaces the sections it wrote. Anything you wrote yourself, above, below or between them, is left alone.
  • A few features add more than text. Skills adds slash commands, Orchestration adds an /orchestrate command and three helper agents, and Stable context adds a step that runs when a session starts. The detail for each says exactly what it adds, and switching it off removes it.
  • Updates arrive on their own. When codecast updates, any feature whose wording improved is refreshed in place. Features you switched off stay off.
  • New sessions pick it up. A session that is already running keeps the instructions it started with. Start a new one to use a feature you just switched on.

Where to go next

Each feature has its own guide: memory, messaging, thread state, ambient awareness, forks and spawn, tasks and plans, triggers, workflows, orchestration, skills, the visual canvas, published pages, browser, computer use and typecheck.

When something is off

What you noticeWhat to do
The switches are greyed outThe machine is offline. Start codecast on it, or pick a machine that is online
An agent doesn't use a feature you just turned onStart a new session. Running sessions keep the instructions they started with
A feature is on for one computer but agents on another don't know itPick the other machine at the top of the page and switch it on there too

For agents and scripts

The same switches exist on the command line: cast install <feature> turns one on for the machine it runs on, and --disable turns it off. The CLI reference lists them.

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