Skip to content

Running agents from the board

On a pipeline board, the board tells agents what to do, and the chat does not. A card’s lane says who acts next. Drag a card into a lane an agent works from, and the agent knows what is wanted. This page shows how that works, from the go-ahead you give to the evidence the agent leaves, and ends with one card carried from Ideas to Done.

It assumes you have a pipeline board and the Lanework skills installed. If not, start with Your first board with Claude.

Each lane has a note that says who acts on its cards and what starts them. The Lanework skills read those notes, so an agent knows whether a card is its turn or yours.

LaneWho actsWhat starts it
IdeasYouYou triage each card on to Shaping, or out. Agents file new ideas here.
ShapingAgentYou place a card here. The agent develops it into a proposal.
ProposedYouYou review each card: approve it, bounce it to Shaping, or reject it.
ApprovedAgentYou move a card in. That is the go-ahead, and the agent builds the card.
ActiveAgentThe agent moves a card in as it starts, and builds it.
DoneNobodyThe agent that built a card moves it here when its done-when is met.

Issues and Tasks are side entrances. Issues hold something broken until you move it on. Tasks hold small chores that need no shaping, and you move each one to Approved.

Moving a card into Approved is the go-ahead to build it. A watching agent starts on the move, with no message to send. Without a watch, the card is built at your next sweep. Either way, the agent takes the top card into Active, builds it, and closes it with evidence in a comment. Approved is a build queue, top card first, so you set the order by dragging cards up or down.

The spec is frozen once a card is in Approved. If the scope changes, the card goes back to Shaping.

Approving a card does not answer its open questions. If a card still has a decision open, the agent does not build it. It asks you again on the card.

Agents never move a card through these two gates. They stop at the gate and leave the move to you.

  • Triage, out of Ideas. Ideas is the inbox. You decide which cards go on to Shaping, and which do not.
  • Review, out of Proposed. When a proposal is ready, the agent moves it into Proposed and stops. You approve it, bounce it to Shaping for more work, or reject it.

Everything between the gates is the agent’s. Moving a finished proposal from Shaping into Proposed is the agent’s job, not yours. Dragging a card into a lane that is not an agent lane, such as Ideas or Proposed, is never taken as an instruction.

A sweep is a single pass over the board. Ask Claude for one in a sentence, such as:

Sweep the Acme Pipeline board and work the approved cards.

Claude reads the board’s lanes, then reports what waits on you: cards at a gate, and questions that are still open. It leaves those alone. It hands the work it can do to subagents, and tells you which model tier each one got.

The tiers are cheapest first, and the cheapest one that fits the work is used:

TierUsed for
haikuMechanical work: inventories, formatting, running builds and tests.
sonnetRoutine work: shaping a clear card, building a tightly specified card, docs.
opusComplex work: tricky debugging, migrations, a spec that still leaves hard calls.
inheritOnly when the agent itself has to make architectural judgment calls.

When two or more approved cards are independent, or the review needs to be independent, the sweep sets up a build team instead of working them one by one. A sweep runs once, reports, and stops. If you want something that keeps going, use a watch.

A watch is a session that stays up and reacts to the board as it changes. Start it in your session with:

/lanework:watch

With one board in the project, that is all. With several, name the one to watch after the command. You type this command yourself. Claude does not start a watch on its own.

When it starts, the watch reads the board’s guide, its description and every lane note, so it knows the rules. It also looks at cards already sitting in agent lanes, because no event fires for a card that was there before the watch began. Any such card that no agent has claimed yet is treated as a work order.

Then it waits. While it runs, a watching agent:

  • Treats a card moved into an agent lane as a work order, and acts on it. That is how Shaping, Approved and Active start work.
  • Answers your new comments on a card, and folds a ruling into the card’s body once you have given one.
  • Skips its own writes and ignores comments from other agents.
  • Hands substantial work to subagents on the tiers above, and posts a plan to the card’s thread first, so the thread shows who is doing what.
  • Reports after each event it handled: which board, what arrived, what it did, and what sits at a gate.

The watch ends when the session ends. After you resume a session, start it again with /lanework:watch. It uses fswatch to see changes when it is installed, and a short polling loop when it is not.

When an agent needs a decision only you can make, it does not ask in chat. It posts an ask on the card and sets a waiting flag. The card wears a mark, and its lane header counts it. View ▸ Waiting on Me shows only those cards.

An ask starts with @ and your handle, offers its choices as buttons, and takes one decision. Click a button, or write a reply in the card’s thread. Once you have, Lanework clears the flag on its own. An agent’s reply never clears it. A watching agent then reads your answer and carries on.

Agents keep records and asks apart. A record says what was done and why, and it never mentions you. Only an ask does. Because of that, a mention means a card is waiting on you. See Working with agents and Waiting.

Here is one small card, carried through the whole pipeline on an example board named Acme Pipeline, with a watch running. Every move is a drag on the board, and every reply is a click on the card. Nothing is typed in chat.

The comments below show what the agent writes at each step.

1. You file the card in Ideas. It is a single line: “Add a Quick start section to the README.” The body reads “New users do not know what to run first after installing.”

2. You drag it to Shaping. This is the triage gate. A card moved into Shaping is a work order for a watching agent, which claims the card with a comment before it starts:

START: shaping this card into a proposal.

  • Plan: read README.md and check.sh, write the scope, risks and done-when into the body, then move the card to Proposed.
  • Tier: sonnet. The card is small and its goal is clear.
  • Claim: this comment marks the card as taken, so no second session starts on it.

3. The agent shapes it. It rewrites the card’s body into a proposal with a scope, a done-when and the one decision it cannot make. Then it posts a record, and a second later an ask. The card now shows the waiting mark.

Shaped: the card has its scope and done-when, and one open call on where the section sits.

  • Decided: only README.md changes. check.sh already tests for the section.
  • Decided: the section names acme init and says what it creates.
  • Open call: placement. Both options are in the body, with B recommended.
  • Accepted limitation: the section stays a few lines. No tutorial.

The ask is the only comment that mentions you:

@kim Where should the Quick start section go in the README?

Options:

  • A: Above Install, so it is the first thing a reader sees.
  • B: Below Install, so the command follows the step it needs.
  • Recap: Explain this in plain terms first

Why now: the card cannot reach Proposed until this is ruled.
If no answer: blocked. Placement is the card’s one open call.
Context: the comment above.

4. You click B. The click posts your answer to the thread as a comment: “B: Below Install, so the command follows the step it needs.” The waiting flag clears. The agent writes the ruling into the card’s body, since that was the last open call, and moves the card to Proposed:

Ruling recorded: Quick start goes below Install, and the card moves to Proposed.

  • Recorded: the open call in the body now reads “B, below Install”.
  • State: no open calls are left. The card is in Proposed, the review gate.
  • Next: the owner approves, bounces or rejects it.

5. You drag it to Approved. This is the review gate, and the go-ahead in one move. The agent claims the card, moves it to Active and builds it:

START: taking this card into Active on branch quick-start-readme.

  • Plan: run sh check.sh to see it fail, add the Quick start section below Install, run the check again, commit on the branch.
  • Tier: sonnet. The spec is tight and one file changes.
  • Claim: session claude, branch quick-start-readme. No second session starts on this card.

6. The card lands in Done. The agent moves it there when the done-when is met, with a closing comment that quotes what it ran:

Done: the README has a Quick start section below Install, and the check passes on the branch head.

  • Decided: the section sits below Install, as ruled on this card.
  • Changed: README.md only. check.sh is untouched.
  • Evidence: before the edit, sh check.sh printed missing: a Quick start section and exited 1. After it, on quick-start-readme at bd20a70, it printed ok.
  • Differently from the card: nothing.

You moved the card twice, at the two gates, and answered one question with a click. The agent did the rest, and left its reasoning and its evidence in the card’s thread.

Everything an agent writes to a board, and how to read and answer it, is in Working with agents.