I was running several coding agents at once and spending more time working out what each one was doing, and reading everything they wrote, than actually deciding anything. So I built something for myself: each task on a card that tells me only what I need to know at that moment, what the agent is doing, what it changed and what it needs from me, instead of a long chat I have to read back through. The work moves through stages on its own and stops when it needs a decision, so I can still answer for the code it produces. That grew into Grid Console, which other people can now use too.

A card in Review, from the interactive demo: the approved plan, a decision that changed during implementation and the findings that need attention.
A card in Review, from the interactive demo: the approved plan, a decision that changed during implementation and the findings that need attention.

Where it came from

When I started running agents in parallel, I assumed the limit on how many I could run would be cost, or rate limits, or something like that. It turned out to be my own attention.

I'd have a bunch of tmux sessions open and be constantly switching between them, trying to recall which agent was doing what, whether it was waiting on me or still going, and what had changed since I last looked. Every answer was somewhere in a long conversation, so I'd scroll up, read and reconstruct it before I could decide anything. Then the same for the next session.

Doing that once is fine. Doing it every time I switch, all day, takes a lot of energy, and it's energy that doesn't go into the actual decisions.

What actually happened is that I'd end up working with fewer and fewer agents. Not because I'd decided to, but because managing a lot of them was just hard.

So I started thinking about separating the long chat from the information I actually need to know. That's where Grid started.

What a day looks like now

A task is a card: a Markdown file with the task, the plan, the decisions and the progress. I've spent a lot of time on this part, working out what I need to know at each moment and getting the agent to write exactly that. The conversation is still there when I want to see what the agent actually did. I don't need it to remember what the task was.

The board shows every card in its stage, and the ones waiting on me are highlighted. It looks like a kanban board, except I don't move the cards. They move when the work passes a check, and stop when they need me. If nothing is highlighted, nothing needs me.

Each stage puts something different on the card:

  • Prepare: an agent investigates the request and the codebase and writes a plan: what will change, which files, how it'll be tested, what proves it's done. If a question would change what gets built, it's asked here. I approve or send it back.
  • Doing: a fresh agent implements the approved plan in its own worktree, with the card as its brief.
  • Review: the approved plan next to what actually happened, changed files grouped by the work they belong to, and anything that deviated, with the agent's reason. I can tell whether the reason is good without reading the transcript.
  • Deliver: the branch lands, as a merge, push or pull request, depending on the project.
  • Verify: the checks we agreed on in Prepare run against the delivered result.
  • Close: anything worth keeping is written to project memory for the next card.

Small changes skip most of this. A card has a type, and a chore or a manual change takes the short path. Difficulty is a separate setting, and it decides which model picks the card up rather than how many stages it walks.

Not every card is an implementation task either. A Masterplan breaks a large job into subcards and integrates the result, a Research card investigates without changing code, Recurring cards run on a schedule, and a Guard sits in Inbox and files a run card each time the event it watches fires.

If an agent needs a decision after I've left my desk, I answer from my phone. That's Tailscale back to my machine and Grid's web interface installed as a PWA for now, with a native app still being built. It's all on the card.

I use Grid to build Grid, and I've been working on this idea for over 9 months. There's a lot in it by now, but all of it is there for the same reason: less to read, less to reconstruct and a clear point where I'm done.

Where this gets interesting: device sync and collaboration

Because every decision and every human action happens on a card, cards are something a team could share. Everyone would see the same board and the same cards, while the sessions keep running on each person's own machine.

That would mean I could pick up a card a colleague's agent prepared, approve a plan someone else wrote, or review changes without reading the session log that produced them. What I need to know is on the card, whoever started it.

None of that works yet. Today a card lives on the machine that ran it and can't be handed to someone else. That's what I'm working on next.

If this sounds familiar

Grid is a desktop app with its own local daemon inside, running on your machine, with Claude Code, Codex and Copilot as agents on your own provider accounts. Codex and Copilot are both marked unstable at the moment. It's in alpha and free to use. Commercial use and collaboration features will be paid once they're ready.

If you're the person with 8 tmux windows and 5 worktrees, I'd like to know what you're still doing by hand once several agents are running. Send me a DM.