cursor

Subagents + verifier pattern for Cursor agent ops

Planner proposes steps against the brief. Implementer changes code in a bounded seat. Verifier (auditor) scores the result against acceptance criteria—and should not hold write tools when you want an honest check. Split into subagents when the job spans packages or needs a separate “did we meet the brief?” pass; keep one agent for small, single-file fixes. AGENTS.md owns the roster and stop rules; Cursor subagents are how the seats run—not a replacement for the contract. This is kit-backed agent ops, not multi-agent fluff. Soft path: /free; pack: Agent Starter Kit ($47).

Who this is for

You’re past “one mega chat that plans, codes, and rubber-stamps itself.” Context bleeds. Scope creeps. Nobody can say whether the change met the brief without re-reading the whole thread. You want named seats with clear tool boundaries—planner / implementer / verifier—backed by a portable `AGENTS.md` roster, not a marketing diagram of “AI team members.”

Official Cursor docs for subagents are the authority for product UI and flags. This post does not rewrite that help center. It owns the ops pattern: when to split, what the verifier may and may not do, and how the seats map onto a kit desk (see also Cursor rules vs skills (and Spec Kit) and One AGENTS.md for Cursor, Claude Code, and Codex).

Pattern in words (planner → implementer → verifier)

Three seats, one brief:

  1. Planner — reads the brief and repo constraints; proposes a step list and acceptance checklist; does not ship product code as the default path.
  2. Implementer — executes the approved steps; owns write tools for the scoped paths; stops at reviewable artifacts when the change is irreversible or externally visible.
  3. Verifier (auditor) — checks the implementer’s output against the checklist; reports pass / fail / gaps; does not rewrite the product story or expand scope.

Hand-offs stay short: planner → checklist + plan; implementer → diff / artifact; verifier → scored checklist. The main thread (or lead seat) consolidates—don’t paste entire essays between seats.

Boundaries (keep the verifier honest)

SeatMayMust not
PlannerPropose steps, risks, acceptance criteriaSilently expand product scope mid-flight
ImplementerEdit scoped paths; run local verify commandsSkip the checklist or “fix” failing checks by rewriting criteria
VerifierRead diffs, run checks, score against criteriaHold write tools when you want an honest audit; rewrite the story to make it pass
AGENTS.mdName the roster, stop rules, and when to splitBecome a dump of full skill prose

Rule of thumb: if the same context both wrote the change and grades it, you don’t have a verifier—you have a self-review. Prefer read-only (or check-only) tools on the verifier seat.

When to split vs keep one agent

SituationUse…Why
Single-file fix, clear acceptanceOne agentSplit overhead costs more than the check
Change spans packages / servicesPlanner → implementer → verifierSeparate “meet the brief?” pass
High blast radius (auth, payments, publish)Split + hard stops in AGENTS.mdVerifier + human approval before leave-the-box actions
You’re debugging vibe, not shippingOne agent + short rulesDon’t invent seats for exploration

Debug order when results feel soft: confirm the verifier had the checklist → confirm write tools were off the verifier → confirm `AGENTS.md` still names stop rules → shrink the implementer scope before adding more agents.

What the Agent Starter Kit is for

The Agent Starter Kit ($47) packages harness templates and agent-ops patterns that include multi-agent seats under an `AGENTS.md` router—planner / implementer / verifier as kit-backed ops, not generic multi-agent theater. Soft path: /free first if you want the roster/checklist mindset before buying.

Companion on the same shelf: Grok Bot role templates that stop before send/publish/pay for Bot-description stop rules that mirror these boundaries.

Soft next step

Name the seats, keep the verifier honest, and leave the roster in `AGENTS.md`—subagents run the pattern; they don’t replace the contract. When you want the pack packaged, use /free for the starter desk, or the Agent Starter Kit ($47) for harness templates and multi-agent ops seats. No rush—ship the checklist into your own runbook either way.

FAQ

What is a verifier subagent?+

A scoped agent whose job is to check the implementer’s output against acceptance criteria — not to rewrite the product story or expand scope.

Planner vs implementer vs verifier?+

Planner proposes steps; implementer changes code; verifier scores against the checklist. Keep write tools off the verifier when you want honest checks.

Does this replace AGENTS.md?+

No. AGENTS.md defines the roster and stop rules; subagents are how Cursor runs the seats. The contract stays in AGENTS.md.

When is one agent enough?+

Small, single-file fixes. Reach for planner/implementer/verifier when the change spans packages or needs a separate “did we actually meet the brief?” pass.

Soft next step?+

/free, then /products/agent-starter-kit ($47) for ops patterns that include multi-agent seats.

Get the free starter

Value first, then a kit when you are ready. No fake urgency. Start with Harness Desk Starter at /free.