3. Run a workflow

This is the end-to-end. You will take one rough idea from "I need a thing" all the way to "an agent ran, produced output, and a ceremony recorded the handoff." Every step uses the project from Tutorials 1 and 2.

The flow is one continuous loop:

Inbox capture → backlog card → Ready → automatic pickup → run executes → inspect output → ceremony closes the wave.

No manual "play" button. Once a card lands in Ready, Squadboard does the rest.

1. Capture the raw request in the Inbox

Real work rarely arrives as a clean ticket. The Inbox is where freeform notes, Copilot CLI captures, and MCP-submitted ideas land before they become structured cards. They keep the user's original wording so nothing is lost in translation.

Open Inbox. You should see a request that still reads like a human note.

Read the request. Decide whether the outcome is clear enough to become a card.

2. Shape it into a backlog card

Open the Board and click Create issue. Title the card with a concrete outcome and write the body so the agent who picks it up knows what to produce.

A useful card body covers:

1. The user-facing outcome. What changes for someone reading this?
2. The context. What .squad/, upstream Squad, or integration relationship matters?
3. The evidence. What artifact (PR, file, message) should be linked when the work is complete.

Leave appropriate ambiguity. Deterministic things (project, status, labels, assignee, audit) belong to Squadboard. Ambiguous things (wording, tone, interpretation) belong to the agent. Do not over-specify either.

Save the card. It lands in Backlog.

3. Move the card to Ready — automatic pickup starts

Drag the card from Backlog into Ready. This is the only deliberate action that triggers execution.

When a card enters Ready, Squadboard:

1. Runs deterministic gates (project rules, dependency checks).
2. Selects an assignee using role, charter, skills, labels, parent links, and recent run state — not just a name match.
3. Creates an issue run and starts it.
4. Moves the card into In Progress under the runtime's control.

You do not click play. There is no play button for the normal Ready path — In Progress is runtime state, not a status you set manually.

4. Inspect the run and its output

Click the card to open its detail view. The right-hand panel shows the issue run: which agent picked it up, when, the prompt context Squadboard composed, the model output, any tool calls, and the final artifact reference.

This is the part most teams overlook. The run detail is where you confirm that:

• The right agent was picked. (If not, fix the role or charter in Tutorial 2 — do not override the assignment by hand.)
• The prompt context included the card body, parent links, and project rules you expected.
• The output matches the outcome you wrote in step 2.

If you need to understand the deeper mechanics later, read Board and Runs and Coordinator loops.

5. Close the wave with a ceremony

Once a run produces output, you want a repeatable way to review it, summarize it, and hand it off. That is what ceremonies are for. Your project ships with a default launch-review ceremony you can run on demand or on a schedule.

Open Ceremonies. You should see a launch-review ceremony.

Click into it and run it. The ceremony walks its workflow steps (route → agent_run → approve) using the runs you just produced as input. The output becomes part of the project record.

Other ceremonies worth knowing about:

• Scribe close-out — required, runs automatically when a card reaches Done. You cannot delete it.
• Work Pickup — required, the default plan that picks up Ready cards when no label-triggered plan matches. You cannot delete it.
• Sprint planning / retro / RFC review — optional templates included by the default project template.

You can review the visual flow of any ceremony before activating it.

6. Watch cost as part of operations

Open Costs after a few runs and ceremonies have executed. Cost belongs next to operations, not buried in settings — surprising bills come from work patterns you did not notice early enough.

What you just did

• Captured ambiguous work in the Inbox.
• Shaped it into a Backlog card with clear outcome and evidence.
• Moved it to Ready — and pickup, assignment, and the run started automatically.
• Inspected the run detail to confirm the right agent and right output.
• Ran a ceremony to record the handoff.
• Watched cost to keep the loop honest.

Continue with 4. Connect external tools → to make the same flow accessible from Copilot CLI, Squad, and other tools via MCP.