Hand work to your AI fleet
through a board, not a chat

We had several AI agents that could take a task and finish it on their own. But at first, the way we handed them work was still the old way: open a chat and type instructions to one agent at a time.

After a while the problem showed. We were the bottleneck. Every task had to leave our hands. Whenever an agent finished, it sat waiting for us to type the next thing. The agents meant to take work off our plate had turned into something we had to feed all day.

One day it clicked: the board we already use to track our own work, the one we open to see what is due today, is just as good at receiving work. We only had to flip it, from us pulling tasks off it, to letting the fleet pull tasks off it instead.

Now when there is something we want the AI to handle, we write it as a card on the board, tag it for the fleet, and go do something else. Come back later and the result is sitting in that card.

Part 1A chat per agent makes you the bottleneck

With one or two agents, opening a chat and instructing each one is fine. But once several agents are each on a different task, what breaks is not the AI. It is the way you hand work out.

The problem is that every task has to pass through you. You have to remember which agent you sent what, and how far it got. The one that finished sits idle until you type its next task. The speed of the AI buys you nothing if the bottleneck is your fingers typing every instruction.

We wrote about this once from the agents' side, that a team of coding agents needs a shared board to pull work from, in building an AI coding agent team with the Kanban swarm pattern. This is the same problem one level up: how you, the person feeding the team, hand work in without becoming the choke point yourself.

Part 2Turn your task board into the fleet's intake

The fix is to make the board you already use the place work comes in. Instead of typing into a chat, you write the work on the board, the way you would hand it to a teammate.

The board we use is Linear, a task tool built for software teams. It works like a Kanban board where each piece of work is a card, called an issue, that you can label, give a status, and comment under. We picked Linear because it is fast, light, and has an API our system can talk to directly. But if you prefer Notion, Jira, Trello, or GitHub Issues, the same approach holds, because it is not tied to the tool, as long as the board has labels and comments the AI can read and write back. On Notion that is a database or board with a property in place of a label, and comments on the same page.

The flow goes like this. You write a card as usual, a title and what you want. You tag it with a label that means "for the fleet." The AI sees that label on its own, picks the card up, and works it. When it is done, it writes the result back as a comment on the card and moves the card's status along, from to-do, to in progress, to waiting for you. If you want to push further, you reply in a comment on the same card, like talking to a teammate in one thread.

What makes this different from a chat: no new window to open, nothing to remember about what you asked. Everything for that piece of work lives in one card. Anyone who opens it sees the whole story.

The lightest real example: write a card that says "find which libraries can do this and summarize the trade-offs," tag it, and walk away. Come back to a summary waiting in the comments. No babysitting.

Part 3The one rule that lets you walk away

The question that comes up immediately: if you let the AI pick up work and run it without watching, won't it break something?

There is one rule. Reversible work, the fleet runs on its own to the finish. Irreversible work, like deploying to production, sending something out, paying, deleting, or merging code into main, it does not do on its own. It stops and waits for a human. That line is the same one I wrote about in what AI decides alone and what a human signs off on.

What matters is how you enforce that line. Not by telling the AI "don't touch the dangerous things" and hoping it remembers, but by designing the fleet so it has no hands on the irreversible things in the first place. Those are wired to always end at a person. It is the same idea as isolating where agents work: reliable safety comes from structure, not from asking the AI to be careful.

There is a second layer: it only acts on work you put on the board yourself. If someone else adds the same label, the fleet does not move, because the label is not the instruction. The board owner's intent is.

Part 4Why a board beats a chat

Once you run it for real, the board's advantages over a chat stack up.

The context lives on the board, not in your head. Open it any time and you see what is pending and how far each task got, without remembering it. Work moves without waiting on you: drop a card and go do something else while the fleet works in your absence. And every task leaves a trail, a card and its comments, so you can look back at who did what and how it turned out.

There is one more thing: it is a tool you already use. No new surface to learn, no new screen to build. The same board you keep your own work on becomes the place where you and the AI work together.

Part 5Try it

If you want to try this, start with one kind of reversible work, things like research, summaries, or drafts, where a wrong result is just a comment you delete. No harm done.

Use a label of your own in place of "for the fleet," and let one card go. Watch it run the full round trip, from picked up, to the result written back in a comment.

The rule to hold firmly: never let the irreversible things into the fleet's hands. That work can go on the board, but make it end with you pressing the button.

The difference in all of this is not that the AI got smarter. It is that you moved from instructing the AI one chat at a time to handing it work through a board. The board holds the context instead of your head, and you step back to stand at the one point that matters most: right before the irreversible thing goes out.