Agents, on the canvas.

Coding agents learned to work in teams this year. A lead agent splits a task, hands the pieces to workers in their own checkouts, and reviews what comes back before anything is merged. All of that happens as lines of text in a terminal or a chat panel.

Design tools are spatial. Artboards sit side by side, and you can see who is working where. So I wanted to find out what orchestration looks like when the work is visible. This is a playground for that question, not a product.

I started by reading how MonoCode, a desktop app that runs several coding agents side by side, orchestrates them. The rules are good. The lead proposes a plan as an editable card and nothing runs until you approve it. Each worker owns a write scope; when two scopes overlap, the second one waits. Workers never interrupt you: the lead answers their questions and only passes on the ones that are really yours. And a finished task isn’t accepted until the lead has reviewed it.

In a terminal, each of those rules is a status word in a list. On a canvas, each one can be something you see happen.

Experiments in a made-up tool feel made up. The hero on paper.design turned out to be real HTML exported from Paper itself, so I captured it at the right moment and kept its tokens, shadows and icons exactly. Then I gave the right panel a second mode for agents.

Everything after this is drawn on top of that rebuild: the canvas pans and zooms, sections hold the new artboards, and the agents live in the panel you already use for design.

The first real question was small: where do you switch between designing and talking to the agents? I built the same switch five ways. All five read the same run state, so wherever it lives it can tell you something: a blinking dot while the lead thinks, coloured dots while helpers work, an amber pulse when someone needs you.

That last one matters most. Even in Design mode, you can see that an agent is waiting on you.

My favourite is the tool rail. Picking the agent like you’d pick the Pen tool says what you’re about to do: ask, not draw. The dock is the most informative and the loudest, so I’d keep it for moments when a run actually needs attention.

Every agent is a small lit sphere with two eyes. I didn’t want a spinner per row, so the face carries the state: a hop while working, a glance up while waiting on someone, a tilted head when it has a question, a squint after hitting a wall, and happy arcs when it’s done.

The same face appears in the task row, on the canvas cursor and in the collaborator stack, so one agent reads as one character wherever you see it.

Then came the runs. Each one is a different shape of teamwork, scripted end to end with a pointer standing in for you: fan out, work in order, wait on a lock, ask, recover, compete, critique, branch, and keep watching after the run is over.

The timings are staged so you can follow each interaction. Each run pairs its notes with a diagram, and the live demo sits right below them. Watch run plays it in place; Close or Escape stops it.

The detail I’d keep from all of this is the wire: a thin dashed line from a helper’s row in the panel to its cursor on the canvas. It answers “which row is that?” without labels, it streams while the helper writes, and it turns solid when the helper is stuck. When the helper flies home, the wire goes with it.

Underneath the runs is a small state machine with fourteen states: idle, composing, reading, planning, awaiting approval, running, and the side trips a run can take, like asking you, recovering, judging, critiquing, merging or watching. The runs only send events. The panel, the switch, the prompt placeholder and the faces all read the state.

That split made the experiments cheap. A new run was mostly a new script; the interface already knew how to show what was happening.

I’d keep the agents close to the work. Clear ownership matters more than another status message, and people should be able to step in without interrupting the whole run.

Still open

• How do several people and several agents share one canvas without it turning into noise?
• Undo for a whole run: which layers did it touch, and can they roll back together?
• Budgets. A run that stops at a time or cost limit should leave the unfinished artboards as honest placeholders.