Agents, handoffs and the wall

Several agents running at once is only useful if something tells you where to look. Grid Console keeps cards and agents apart, hands a card between agents on fixed arrows, and puts the whole fleet on one screen, or on the wall.

Cards and agents are separate

A card is the work. An agent is one run of one stage of that card: a record with a stage, a model, a context window, a lifetime and a cost. The model is resolved when the agent is spawned, from the card's difficulty crossed with the workspace budget and the role the stage plays: research and planning, implementation, or delivery and validate. That matrix is why per-stage models exist. Prepare can out-think the build on a stronger model while Doing runs a cheaper one, because everything the next agent needs is written on the card. See models.

Handoffs

Not every arrow starts a fresh agent, and only one always does. Any arrow into Deliver ends the conversation and starts a new one. Every other arrow keeps the agent already running when the next stage wants the same model, the same effort and the same directory, and replaces it when it does not.

A fresh agent is told it is new here and that the card is the whole handoff; a kept agent is told the card has moved and stays with it. When a handoff replaces the agent, the replacement really is new: nothing of the old conversation is resumed.

Two things make handoffs hold. Every prompt Grid types into a session is confirmed by the agent's own hook, resent up to twice, and flagged on the card if it never lands. And when the daemon boots it rescues any card sitting in Deliver or Verify with no live session, because a card can only be there by handoff.

The Agents page

The Agents page has three tabs: Sessions, Office and Agents. On Sessions, the By health view groups the same work by the agent doing it, by what it needs from you, so you can work top to bottom and always know what is next. The office shows it as a floor you can walk, and the Agents tab holds the agent definitions.

Each agent card shows the card it holds, the open question if there is one, a window of its task list, its model, how long it has been running or waiting, what it has cost, its worktree (amber when it is working on the checkout itself) and its subagents with how many are running or failed. That task list is the card's own checklist merged with whatever the session has ticked, the same list the board tile draws.

Agents on this card

A card that has had more than one agent gets a roster of its own in the session rail: every agent that worked it, one row per conversation per stage-run, oldest first. A row carries the stage, model · effort, how long the run took, what it cost, a live dot while it is still running, and ↻N where daemon restarts folded several re-registrations into one chain. Clicking a row opens that run's own slice of the conversation, read-only: the head reads PAST AGENT · … · read only and the composer is replaced. A card with one agent draws no roster, because that agent is the one already on screen.

Relations on the board

Hover a card on the board and Grid draws its relations to the others.

A masterplan folds its subcards' status and questions into one card; see masterplans and subcards.

What an ask carries

A question arrives with the card, the diff and the answers you can give. Under it sits Help me decide: chips that ask the agent something on the side without answering yet. A question that takes more than one answer draws its choices as toggles and holds them until you submit that question, rather than sending on the first pick; on Needs you such a question opens the card instead of offering one-tap buttons.

Progress you can read

The card body is snapshotted when you approve the plan, and Review reconciles the work against that snapshot. The task count merges the plan's checklist with the agent's own task list, so a step the agent adds is counted, and the card sheet marks it as DRIFT FROM PLAN rather than renumbering silently. Never a percentage: tasks are not equal in size.

Human approval

There is no autonomy dial. A card stops for you at the plan and at the diff unless its type or its capture says otherwise: a Chore's plan is pre-approved, and the capture sheet's Skip plan approval and Skip human review waive either gate for one card. Findings, open questions and delivery checks still hold a card whose review was skipped, and Settings › SDLC says which roles may move a card out of Prepare or Review.

Agent permissions

There is no OS sandbox. A session spawned by Grid runs like your own claude in that worktree, under your own Claude Code settings. What Grid still enforces is a per-session deny list: your real checkout, credentials, Grid's own board state, the project's protected branches, and the one settings file that would let a session grant itself more. Answers you give with "don't ask again" are kept as standing grants for the project until you revoke them.

Schedule

A card can be queued from its sheet: for the window reset, for a time, or daily or weekly. Settings > General sets how many scheduled cards a project may run at once and which projects pause first as the week fills.

A board column can carry a cap of its own: how many sessions may be live in that column at once, across every project. It is set from the column's header on the board rather than in Settings, and it gates every start (pressing the button, a dependency autostart, a scheduled card, a cadence firing), refusing with the column named. A column with no number is not capped, and the board header's Limit agents switch turns the whole set off without forgetting the numbers.

The wall and big screens

Open the app with ?embed=1&wall=1 on a wall display and it becomes two panes, board and agents, with a picker per pane. On a large monitor the plain app keeps the single view, and a zoom ladder keyed on the screen's long edge raises the type. The Wall mode row in the menu only tells you this.

Phone and other machines

Sync between your own devices and shared workspaces arrived with 0.2.4 and 0.2.5: turn on sync for a workspace and connect another desktop, and from 0.3.0 a desktop pairs with an iPhone by QR code. Answers can come from any device while the work runs on the machine where it started. The phone screens are also in the desktop app itself at 700 pixels wide: sessions, board and capture.