Three ways to orchestrate coding agents from a kanban

1Turn the plan into tickets

All three patterns start the same way. You plan in chat, and the plan becomes tickets on the board. Create a project for the app in Morion, then ask Claude Code to add a kanban folder to it and one task per piece. It calls folders_create and notes_create. Each ticket gets a body with acceptance criteria and lands in Backlog or Todo.

From here the patterns differ in one thing only: who picks the tickets up.

you, in Claude Code Plan a habit tracker: iOS-first, local storage, weekly review screen. Create a folder "Habit Tracker" in the Morion project Habit Tracker, with one task per piece. Each task: a title, what done looks like, and which pieces it depends on. Put the two that can start now in Todo, the rest in Backlog. claude mo_list_projects folders_create {name: "Habit Tracker", projectId: …} notes_create ×6 · statuses: todo, todo, backlog, backlog, backlog, backlog Created six tasks. Data model and Habit list screen are in Todo.

2Hand tickets to subagents

Pattern A. Claude Code can spawn subagents, and its subagents can use the same MCP servers. Tell the planner to hand out tickets. Each subagent claims one with mo_take_task, which also returns the work packet. It works the ticket, logs progress as comments, and moves it to Review.

The claim is atomic: if two subagents reach for the same card, one gets it and the other gets claimed: false and takes the next one. A card in Doing tells you, and every other agent, who has it.

Best when the pieces are small, parallel, and fit inside one session. Nothing survives the session except what was written to the board. That is the point of writing to the board.

you Take the Todo column. One subagent per ticket. Each subagent: claim it with mo_take_task, do the work in its own worktree, comment progress on the ticket, run the tests, move it to review. Do not merge. I review. claude → subagent 1 mo_take_task {taskId: "Data model", claim: true} → ticket, 2 related notes, project brief · status: doing claude → subagent 2 mo_take_task {taskId: "Habit list screen", claim: true} subagent 1 notes_add_comment "Schema written, 9 tests green" tasks_move {status: "review", message: "ready for review"}

3Hand tickets to Auto-code

Pattern B. Turn Auto-code on for the folder and keep the default template, Code + code review · Mo-driven. Claude writes, Codex reviews shows the two switches. Claude Code can list the folder’s workflows over MCP with workflows_list.

Now a ticket in Todo is picked up by the workflow, not by a subagent. The implementer builds, Mo decides, the reviewer reviews, and if the implementer raises a question, a human gate asks you in chat. The diff waits on its branch until you merge it.

Claude Code’s job shrinks to planning and to moving tickets into Todo when they are ready. The runner is part of the app, so it survives the end of your chat session.

you → Claude CodeCodex approved Data model. Move Check-in flow to Todo in Morion so Auto-code picks it up next.

Best for anything that takes more than one session, needs a second agent’s review, or should run while you are away from the keyboard.

Habit Tracker · KanbanAuto-code · Code + code review

Todo

Check-in flow

next in queue

Doing

Habit list screen

cli_agent · claude2/5

Done

Data model

MoCodex approved. 3 files on the branch: Merge into main.

4Put Claude Code on top as the supervisor

Pattern C. Keep Auto-code running the tickets and give Claude Code a recurring job on top. Check the board. Pull the next ready ticket into Todo when its dependency is done. Read what is in Review and summarise it for you. Flag a human_gate question for you, with the note that already answers it.

Claude Code’s /loop runs a prompt on an interval. That prompt is the supervisor. It never merges. You do.

Best once you trust the loop and the backlog is long. The supervisor is the difference between “a run finished” and “the project moved”.

you, in Claude Code /loop 15m Act as PM for "Habit Tracker" in Morion. 1. Ask Mo what is in review and summarise the reviews for me. 2. If a ticket in backlog has all dependencies done, move it to todo. 3. If a run is waiting for me, tell me which ticket and what it asks, and quote any note that already answers it. Do not answer it yourself. Never merge. Never move anything to done. every 15 minutes mo_ask {projectId: …, statuses: ["review"], question: "What is in review, and what did the reviewers say?"} tasks_move {Check-in flow → todo, message: "Data model is done"}

5Pick a pattern

Match the pattern to the work in front of you, not to the tool you like most.

A · subagents

Small parallel pieces, one session, you are at the keyboard. Nothing to set up beyond the board.

B · Auto-code

Anything longer than a session, anything that deserves a reviewer, anything that should run while you sleep.

C · both

A long backlog with dependencies. The loop does tickets; the PM does the project.

Whichever you pick, the board is the record. Switch patterns tomorrow and nothing is lost, because nothing lived in the chat.

6Questions

Can Claude Code subagents use Morion?

Yes. Subagents use the same MCP servers as the main session, so each can claim a ticket with mo_take_task, comment progress and move it to Review.

Which pattern should I start with?

Subagents for small pieces that fit one session. Auto-code for anything longer or anything that needs a second agent’s review. Both when the backlog is long and has dependencies.

7What you have now

One project on one board, and three ways to work it. Subagents take the small parallel pieces while you watch. Auto-code takes the tickets that outlast a session and brings a reviewer with it. A supervisor prompt keeps the queue moving and leaves the merge to you. Every claim, comment and review lands on the ticket, so the next agent and the next Ask Mo start from the same record.

next20 min

Running an epic

A long backlog with dependencies, worked end to end.

next20 min

Claude writes, Codex reviews

The default Auto-code loop, switch by switch.

Download

Three ways to orchestrate.