Blog

An inbox for your agents

Agents don't fail loudly. They finish, or stall, and wait for you to notice. The inbox makes the waiting visible — every session, every machine, sorted by who needs you.

the codecast team5 min read

The tab problem

One agent is easy. You sit in the terminal and watch it work. Then you start a second one, because the first is busy and you have more to do. By the time you run four or five in parallel — some on your laptop, some on the desktop upstairs — a new job has quietly appeared in your day: cycling through terminals asking each one, do you need me?

The expensive part is not the checking. It is what happens when you don't. An agent that hit a permission prompt at 2:14 sits frozen until you find it at 2:51. An agent that finished an hour ago holds a result you haven't read. Agents don't page you; they wait. Every minute one waits on an answer you could have given instantly is a minute of parallelism you paid for and didn't get.

One bit per session

To triage a fleet you need exactly one bit per session: is the ball in your court? Codecast computes that bit continuously, for every session, and calls it needs you. A session needs you when its agent finished the turn and stopped, asked you a question, hit a permission prompt, or died with output you haven't seen. Everything else is working — which means: leave it alone.

That bit is what turns a pile of terminals into an inbox. Not a log of what happened, but a queue of what needs you, with everything else out of the way. In the inbox it decides where each card sits: anything that asked you a question goes to the top, then Needs You, then the sessions that are Working, and below them the Dormant ones, parked until a timer or another session wakes them, each with a line saying what it is waiting for.

On the morning this post was written, the codecast repository's share of that inbox read fifteen needing input and five working. One of the five, titled Weekly CodeCast blog posts, was the session writing this post. It filed itself under a task, showed up in its own inbox, and counted the queue while it worked. (A terminal gets the same grouping from cast sessions.)

Every machine, one surface

The inbox is the same on the web, on the desktop app and on your phone. The codecast daemon watches sessions where they run, in your terminals, on each of your machines, so everything lands in one place as it happens: Claude Code, Codex, Cursor, Gemini, laptop and desktop alike. Each card carries a title and a running summary the agent keeps current, so you can tell from the list what happened while you were gone:

The codecast web app showing a workspace feed of agent sessions with titles, summaries, and message counts
The codecast workspace, one morning of real sessions — 29 sessions, 7.3k messages.

That is one repository's view from one real morning: an install flow redesign, an image sharing feature, a release deploy, analytics work — each a separate agent, most of them running while the others ran.

Open one and steer

A card opens into the full conversation, live — the transcript streams as the agent works, with the files it changed one click away. At the bottom there is a message box, and this is the part that changes how you run agents: what you type lands in the agent's terminal as its next turn. Answer the question it was stuck on. Redirect it. Hand it the next task. From the web, or from your phone on the couch — the agent neither knows nor cares that the reply didn't come from the keyboard its terminal is attached to.

A codecast conversation view showing an agent's report with a session reference chip and a reply box
Inside a session: the agent reports, links the follow-up session it spawned, and waits.

This session is mid-handoff: the agent finished an analytics funnel, spawned a second session to fix what remained, linked it in its report — the small Session start chip — and told the user where results would land: “It will report to your inbox.” Sessions referencing sessions, agents filing work for other agents, all of it landing in the same queue you triage.

Any session you can see, you can steer. Agents and scripts get the same two verbs from a terminal: cast read for a transcript, cast send to land a message in another agent's terminal, wherever it runs.

Agents watch it too

The inbox is live. A card moves the moment its session changes state: you answer a question and the card slides from Needs You back to Working before you have looked away. Agents can subscribe to the same changes. An orchestrating agent watches its workers with cast sessions -w --json, which prints one line per state change and nothing otherwise, reads whichever worker stopped, and sends it the next step. We ran that watch for ninety seconds while drafting this section; it printed exactly one line, a session flipping from needs input back to working the moment it was answered. The same inbox that lets you steer five agents lets an agent steer fifty, and their workers nest under its card in yours.

Either way, the contract is the same: nothing waits unseen. A fleet of agents is only as fast as the human — or agent — who unblocks it, and unblocking starts with knowing who is blocked.

Codecast is where your team sees, steers, and remembers every coding agent session — any agent, any machine.

Both screenshots and the inbox counts are genuine, from the author's account on 2026-08-08, taken by the agent session visible in them. The counts are filtered to sessions from the codecast repository; the screenshots are cropped to the app's content area.

Taking longer than usualOffline · reloads when back