Running multiple agents without the chaos.

How should I organize the work?

Treat each assignment the way you would with a human team: give it a clear owner, a clear outcome, and one place to follow its progress. A stream of messages may start the conversation, but it does not tell you which tasks are underway, which are finished, or where someone needs a decision.

The same problem appears when several agents work on one project. Two can edit the same file. A third can finish without anyone noticing. Important context gets scattered across separate chats, and you spend more time coordinating than the extra help saves.

A Kanban board gives every assignment a visible home. Pair that board with an isolated workspace for each agent and one place to review what comes back. You get the speed of several agents without managing a pile of conversations.

What do you need before you start?

Three things, and you probably have them already.

• Redeep installed on your Mac. Free to download — it runs natively, not in a browser tab.
• A provider key. Bring your own from OpenAI, Anthropic, Google, OpenRouter, or Vercel AI Gateway. For smaller jobs you can run an on-device model on Apple Silicon with no key at all.
• A project folder. The work you want the agents to do — a codebase, a set of documents, a website directory. Anything on your Mac.

If you need help with the first two, see the getting started documentation. Everything below assumes you can create a board and move a card.

Step 1: Give each task a card

Start by creating a board and writing one card per task you want to run in parallel. A card is not a sticky note — it is a brief, a conversation, and a working session all in one. Write the outcome you want, point it at the right folder, and the card becomes the home for everything that agent does.

Suppose you are preparing a product launch. You might create three cards: one to update the website copy, one to draft an FAQ from support notes, and one to analyze the last quarter of customer feedback. Each card carries its own brief, its own files, and its own progress — they do not share a chat history or step on each other's context.

If you would rather let Redeep organize the work for you, no problem. Start a conversation, describe what you are trying to accomplish, and ask Redeep to create the board and cards. You can adjust the plan before any card starts.

Step 2: Each card runs in isolation

Move each card into the working column and Redeep gives it an isolated copy of the project (technically, a git worktree). You do not need to know git to benefit from this. The everyday analogy is simple: each agent gets a clean duplicate of the project, makes its changes there, and returns a marked-up set you can review.

Because each agent has its own copy, two agents can edit the same file in the same project without overwriting each other. The website agent changes index.html in its worktree; the FAQ agent edits docs.html in its own. Neither sees the other's changes until you decide to merge them. There is no coordination call, no lock file, no "are you done with that?" — the isolation is automatic.

For software projects this isolation is a real git worktree, complete with its own branch. For non-code folders, the same separation applies: each card works in its own space and hands back reviewable changes. You stay at the level of deciding what joins the main version, not mediating conflicts between agents. As an added bonus, you will be able to quickly undo any work you do not like.

Step 3: Watch the board, not tabs

While cards are being processed, the board shows you the state of everything at a glance. Each card displays whether its agent is running, finished, or waiting on a decision from you. You do not need to switch between chat windows or remember which tab has the analysis and which has the draft.

When a card is finished, it contains a summary and the changes from its isolated workspace. You review the diff, decide what to keep, and move the card forward. If something needs a follow-up, you comment on the card — the agent picks it up in the same context, with all its history intact.

This is the part that replaces the chaos. Instead of six browser tabs and a growing sense of unease, you have a board with three columns and a clear answer to "what is happening right now." The board is both the plan and the live workbench.

Step 4: Automate the handoffs between stages

Once the workflow feels right, add a column action to handle the next step whenever a card moves forward. A simple board might use Plan → Implement → Review. Moving a card into Plan can ask an agent to turn the goal into an approach. Implement can start the work in its isolated workspace. Review can bring in a fresh agent to check the result before you approve it.

Column actions are written in natural language and can run automatically when a card enters a column, or wait until you press play. You choose which handoffs are routine and where human judgment should remain in control.

What does it look like when it works?

Before: you open three chat sessions, paste the same project context into each, and hope they do not touch the same files. You lose track of which one finished, which one stalled, and which one quietly edited a file the others needed. You spend more time coordinating than the parallel work saved you.

After: you write three cards on a board, move them into the working column, and step away. Each agent runs in its own isolated worktree. When you come back, the board tells you what is done. You review three diffs, merge what you want, and the work is yours.

The leverage is real: three tasks finished in the time one would have taken, with no overwritten files and no lost context. And because each card is a persistent session, you can hand the same board to the same agents next week and they pick up where they left off.

Where to go from here

Once your agents are running in parallel, the next question is how to make each one better at its job. Skills teach a repeatable method. Specialists divide a large card among focused agents. Familiar tools let them act in the browser, on your Mac, and in the services where your work already happens.

Read the companion guide: Make your bots smarter with skills, specialists, and tools. Or jump to the full project boards documentation for the operating details.