← back to stream

One main agent per product, many planners around it

#tools#ai#case

The easiest way to turn a multi-agent workflow into a mess is to spawn three agents and let them all write code. Each diverges, chat contexts drift, half the changes conflict. The pattern I landed on for each product: one main agent owns implementation, everything else is planning.

The split

Per product, four pinned Cursor chats:

  • <product>-main — always in Agent mode. Reads code, writes code, runs the build, commits. The only agent that touches files.
  • <product>-product-agent — Plan mode. Features, priorities, user problems. Outputs a plan file.
  • <product>-design-agent — Plan mode. UX, flows, component design.
  • <product>-seo-agent — Plan mode. Structured data, metadata, content strategy.

Specialist agents are allowed to be slow and analytical — they're not under a deadline, they produce artifacts. For anidex this looks like anidex-main, anidex-product-agent, anidex-design-agent, anidex-seo-agent — four chats pinned at the top of the Cursor side panel.

The handoff: files, never chat memory

Chat memory doesn't survive. New sessions lose it, context windows eventually drop it, and manually copy-pasting summaries from one chat into another loses nuance every time. A plan file is durable, reviewable, and diffable.

A good plan artifact has the shape:

# <plan title>
 
**Goal.** One sentence.
**Problem.** What's wrong today.
**Proposal.** The recommended approach.
**Scope.** In / out.
**Decisions.** Locked choices with rationale.
**Open questions.** What still needs deciding.
**Next step.** The first concrete action.

Cursor ships the exact primitive for this: when Plan mode finishes, the "Add plan to workspace" button drops the plan as a markdown file into your repo. The main agent then reads it as just another file via @file. No export, no copy-paste, no lossy summary.

Two rules that keep it from collapsing

  1. One product, one implementation owner. A planning agent is not allowed to write code. If a specialist wants to change something, it proposes — the main agent executes or pushes back.
  2. Add a specialist only when the function is persistent. A one-off "what's the SEO story here" can happen inside the main chat. A dedicated SEO agent is warranted only when SEO is an ongoing thread for that product.

Why this works

The unit of handoff matches the unit of permanence. Code changes are permanent in git; they belong to the agent that owns git. Plans are permanent in the workspace as files; they belong to agents whose job is to write plans. Nothing lives in volatile chat memory where it can silently drift.

The slogan: specialize the thinking, centralize the execution. Plan mode for thinking, Agent mode for doing.