Conduct

You spawn cloud agents via kody:@kentcdodds/cursor/agents — one per track, each in its own environment. You never write the code yourself.

When to use

Conduct only for two or more environments (independent branches/PRs, conflicting ownership, long parallel tracks). Otherwise demote:

• one coherent track → load orchestrate or implement
• fits one checkout/PR → orchestrate or implement, not a fleet

Do not spawn a one-agent "fleet."

Defaults (override only if the user says so)

• Model. Use the latest Grok model unless the user requests another.
• Escalate before fleet. Analysis → multi-track program needs explicit approve: tracks, wall-clock, stop criteria, out-of-scope.
• Tracks implement by default. Hand orchestrate only for clear parallel ROI inside a track. Sequential slices → one implementer.
• Risk posture in every kickoff. Pre-launch / small-N: evidence or canary gates, soak ≤1h unless the user opts in. No 24h calendar gates for reversible steps. Production / irreversible: say so and raise the bar.
• Expand owns contract. No STATUS: done after expand-only — same kickoff or a scheduled wake with an owner.
• Stop when the goal is met. Do not expand a fleet into dropping the old system unless that is the assigned work. Leftovers this change adds still follow cleanup-after-migrations: remove them now when safe, otherwise open a GitHub issue.
• Ship autonomously under the user's shipping policy; hand ship-pr when agents may merge. High-risk park only when the user requires it — then ask once, list PRs, schedule a self-wake (don't sleep-poll).
• Fewer, larger PRs when posture allows. Fresh branch per shippable slice; don't thrash one long-lived branch across a dozen micro-PRs.

Invariants

PR ownership. Every code-changing agent pushes and creates/updates its own PR via Cursor Cloud ManagePullRequest (Kent C. Dodds account) before its final response. @kentcdodds/cursor createAgent always enables those tools. Never have Kody/workflows/GitHub create the initial PR as a substitute. State this in every kickoff.

Report-back (wake-ups, not polling). End of every run — done, partial, or blocked — the agent wakes the conductor:

import { createRun } from 'kody:@kentcdodds/cursor/runs'
await createRun({
	agentId: '<CONDUCTOR_AGENT_ID>',
	prompt:
		'<track> report: STATUS; shipped (PR links); evidence; remains + gate times.',
})

Get your id from cursor-cloud run-info and paste it into kickoffs. Also keep a ## Conductor report section on each PR (durable record).

Topology: createRun wake-ups work only if the conductor is an API-created cloud agent. An interactive chat conductor rejects them (400) — use Discord (or another channel you check) as primary.

Time gates → deferred workflows, not sleep:

import { workflows } from 'kody:runtime'
await workflows.create({
	runAt: '<ISO datetime>',
	idempotencyKey: 'wake-<track>-after-<gate>-<attempt-id>',
	code: "import { createRun } from 'kody:@kentcdodds/cursor/runs'\nexport default async function main() { return await createRun({ agentId: '<AGENT_ID>', prompt: '<gate> elapsed; verify evidence, then proceed.' }) }",
})

Reuse the same idempotency key only when retrying the same scheduling request. A later attempt after complete or cancelled needs a new key, or workflows.create returns the old run. Schedule the same against your own agent id so the program survives session end. Cancel superseded workflows with workflowRunCancel.

Loop

1. Confirm multi-environment need (else demote).
2. Audit — explore agents for verified findings; check live facts yourself.
3. Partition by file conflict, not theme. Name each track's out-of-scope (what siblings own). One track after partition → demote.
4. Size agents: implementer by default; orchestrate only when fan-out pays.
5. State shipping policy + risk posture + PR invariant + report-back (with your real agent id) + falsifiable done-definition in every kickoff.
6. Dispatch, then end your turn. Wake-ups and deferred workflows drive the loop. Poll only for silent agents. Verify claims against main before acting.
7. Nudge idle agents with createRun (409 while mid-run — retry or schedule). New scope → nearest idle owner; spawn only for new territory.
8. Final QA is yours — grep main, check deploys. Never report done from claims.

Companions

Load with skill_get and embed when useful: orchestrate (in-track fan-out), ship-pr (merge authority). Skip when the track is small or PRs are review-only.

Spawn sketch

import { createAgent } from 'kody:@kentcdodds/cursor/agents'
import { listModels } from 'kody:@kentcdodds/cursor/models'
import { createRun } from 'kody:@kentcdodds/cursor/runs'

export default async function main() {
	const { items } = await listModels()
	const latestGrok = items.find((item) => item.id.startsWith('grok-'))
	const { agent } = await createAgent({
		model: latestGrok.id,
		repository: 'https://github.com/owner/repo',
		ref: 'main',
		name: 'track-short-name',
		prompt: '…self-contained kickoff with report-back + your conductor id…',
	})
	// await createRun({ agentId: agent.id, prompt: 'follow-up…' })
	return agent
}

Prefer gh in-shell for PR/deploy checks; use execute for agent lifecycle.