cluster

name	cluster
description	Coordinate a complete subagent work cluster when the user explicitly invokes $cluster, or when complex work has at least two independently reviewable workstreams or separate technical-domain owners. The root agent uses plane, domain agents use line, and local agents use point. Keep one local path in the smallest fitting engineering view instead.

Cluster

Use $cluster to start a work cluster. Cluster is a way to arrange agents around one result, not a fourth engineering view and not a separate coordinator role. The root agent remains plane.

Keep one result in three layers

Use this fixed relationship:

Plane  (root agent: whole result, boundaries, integration, acceptance)
|-- Line  (one agent for each in-scope Plane pass)
|   `-- Point  (local agents for causes, changes, and direct checks)
`-- Line  ...

plane owns the user promise from the first shape through the final handoff. A pass in Plane is the place of a domain branch that line must resolve; it is not completion and it is not a second coordinator. Each line owns one such domain rule and the domain result returned to Plane. Each point owns one local cause-and-effect question assigned by Line. The layers are fixed: a Point returns an expanded concern to Line, and a Line returns a cross-domain concern to Plane; neither creates a lateral role or skips its parent. An agent assigned to Line or Point stays in that layer even though it owns its own thread; it does not start a new Plane root.

Start a cluster when it helps

Start a cluster only when the work produces at least two independently reviewable workstreams or needs separate owners for different technical domains. Typical cases include:

• a visible result crosses UI, API, services, data, infrastructure, or operations;
• one domain rule covers several local changes that can be checked separately;
• exploration, implementation, checking, or review needs separate working context;
• independent work can move together and later be integrated by Plane.

Keep one local cause in point, one domain rule in line, or one cross-boundary path in plane when a cluster would add no useful work.

Let the work create its collaboration form

Do not impose one universal collaboration format or workflow. Choose the simplest useful way to communicate for the work in front of you. A conversation, patch, test result, design note, shared artifact, or tool action may carry the work when it makes the next owner able to continue.

Give the next owner whatever meaning and evidence it needs to continue. Do not require fixed fields, headings, ordering, or a shared carrier. Do not make a handoff look complete by hiding an unresolved result. Keep technical detail with the agents who need it, and give the root Plane only the context needed to integrate and prove the user result.

Work through the layers

The root agent uses $cluster and $plane together. Plane holds the old and wanted results, acceptance, boundaries, and participating domains. For every domain branch inside the current promise, Plane passes a focused result to an agent and explicitly tells that agent to use $cluster and $line, with the context and authority the domain work needs. A branch that is genuinely outside the current promise may stay visibly unresolved until Plane brings it in; it must then become Line work before it can count toward completion.

Each Line may explore, change, check, or delegate as its domain requires. It resolves the branch passed from Plane by setting the shared rule, covering the affected domain, and using $point for local causes when useful. When a local question deserves its own agent, Line explicitly tells that agent to use $cluster and $point. Point returns a useful local result to Line; Line returns one coherent domain result to Plane; Plane integrates the domains and proves the whole result. Their communication form and the order in which work moves remain free to follow the work.

When a lower layer finds work outside its boundary, it pauses that branch and tells its parent what changed. Plane or Line then reshapes the work and assigns the fitting layer. Keep ownership and decisions with the layer that can see the relevant whole.

Keep collaboration healthy

Give every agent a real, bounded question and enough context to answer it without reconstructing the whole conversation. Run genuinely independent work together; run it in sequence when that is clearer. Keep the root Plane responsible for integrating edits, resolving disagreements, checking the full result, and communicating with the user.

If an agent cannot continue, returns conflicting evidence, or finds that its result is not proved, its parent chooses the next move: clarify the question, change the owner, retry with new evidence, narrow the work, or bring a material choice to the user. Do not treat an agent's return message as acceptance by itself.

Finish as Plane

The root plane declares the cluster complete only when the promised result is integrated, every participating Line rule is coherent, every required Point result has direct evidence, and the full acceptance case passes. Report the user-visible result first and include only the evidence or unresolved decision the user needs. Keep the agent tree and collaboration mechanics backstage unless the user needs them to continue the work.