Agent Conductor

Orchestrate coding sub-agents (Claude Code, Codex, Cursor, Gemini Code, or any CLI-based coding agent) for maximum throughput on implementation tasks. Use wh...

Security Scan

The skill is an instruction-only orchestrator that is internally consistent with its stated purpose (delegating code-execution tasks to CLI/agent tools) and does not request extra credentials or installs; however it gives broad runtime authority to run agent CLI commands and interact with the filesystem, so use caution when enabling it in a privileged/autonomous environment.

Purpose & Capability

Name and description match the contents: the SKILL.md describes orchestrating coding sub-agents, task decomposition, parallel coordination, and verification. There are no unexpected required binaries, env vars, or config paths declared — consistent with an instruction-only orchestrator.

Instruction Scope

The instructions explicitly tell the orchestrator to dispatch CLI commands (AGENT_CMD), run background/foreground processes, read logs and progress files, and verify output files. All of these are directly relevant to orchestration. However the instructions grant broad discretion to execute arbitrary agent commands and scripts (including reading and writing arbitrary project files and running long-lived background processes), which increases the operational risk depending on what the agent is allowed to run.

Install Mechanism

No install spec and no code files beyond documentation — lowest-risk delivery model. Nothing is downloaded or written by the skill itself.

Credentials

The skill declares no required environment variables or credentials. The dispatch template mentions that tasks may include project-specific env vars (proxy, auth), which is reasonable — those would be provided per-dispatch and are not requested by the skill itself.

Persistence & Privilege

Flags show always:false and default autonomous invocation behavior. The skill does not request persistent privileges, nor does it modify other skills or system-wide settings in its instructions.

Assessment

This skill is instruction-only and coherent for orchestrating CLI-based coding agents. Before installing: (1) Restrict which AGENT_CMD values the agent may invoke (use a controlled wrapper or allow-list) so the orchestrator cannot execute arbitrary system commands; (2) Run the skill in a sandbox or project-specific environment (not with root or system-wide access), since it routinely reads/writes files and runs processes; (3) Ensure any sub-agents you dispatch to are trusted and that their CLI tooling is configured with only the necessary credentials; (4) Review and supply safe completion/notification commands and avoid allowing the orchestrator to accept open-ended prompts that could trigger external network calls. These mitigations reduce the risk introduced by giving an orchestrator the ability to run arbitrary agent CLI commands and modify files.

You conduct. Agents perform.

Route all implementation work — file changes, scripts, data processing — to coding sub-agents. The orchestrating session stays lean: it plans, decides, and validates. Agents do the execution.

Supported Agents

Agent-agnostic. Set your invoke command once:

Agent	Invoke Command
Claude Code	claude '<task>'
OpenAI Codex	codex '<task>'
Cursor Agent	cursor-agent '<task>'
Gemini Code	gemini-code '<task>'
Any other	your-agent-cmd '<task>'

Use AGENT_CMD as a placeholder in the examples below.

When to Dispatch

Dispatch when the task involves any of:

• Writing or modifying files (even one line)
• Running scripts or processing data
• Execution time > 10 seconds
• Batch operations over multiple items

If it produces file changes → dispatch it.

Dispatch Template

## Task: [name]

### Requirement
[One sentence: what to produce and where]

### Context
- Project: [name and purpose]
- Relevant files: [paths]
- Data format: [brief description of inputs/outputs]

### Acceptance Criteria
- [ ] Output file exists at [path]
- [ ] Contains [N] records / passes [specific check]
- [ ] No errors in [error field / log]

### Gotchas
- [Known pitfall 1]
- [Known pitfall 2]

### Environment
- Language/runtime: [python3 / node / go / etc.]
- Working directory: [path]
- Special config: [proxy, auth, env vars if needed]

When done, notify with:
[your completion notification command]

Execution Mechanism

Duration	Mechanism
< 5 min	Foreground: exec pty:true command:"AGENT_CMD '...'"
5–30 min	Background: exec pty:true background:true timeout:1800 command:"AGENT_CMD '...'"
> 30 min	Agent writes script → run in screen / tmux

Use pty:true if your platform requires it (needed for Claude Code; check other agents' docs).

Task Decomposition

Split large projects by stage, not by feature. Each stage must be independently verifiable.

Split when any of these apply:

• Runtime > 30 minutes
• More than one script needed
• Batch > 100 items
• Output of one step feeds the next

Stage 1: Prepare data  →  clean_data.csv        (< 2 min)
Stage 2: Process       →  results.json           (needs Stage 1)
Stage 3: Report        →  report.md              (needs Stage 2)

See references/patterns.md for parallel coordination, checkpoint/resume, and domain examples.

Acceptance Checklist

After any "done" signal, always verify:

1. File exists — confirm output path
2. Count correct — expected N vs. actual N records
3. Non-empty — spot-check 2–3 outputs
4. No silent errors — check error fields and null rates

A completion signal ≠ acceptance. Run the checklist.

Error Handling

Symptom	Action
Timeout, no output	Check process log → kill and re-dispatch with more context
File missing after "done"	Read execution log → add context → re-dispatch
Partial completion	Check progress.json → resume from checkpoint
Fails twice in a row	Stop re-dispatching → debug in orchestrator session

What NOT to Dispatch

• Simple reads → use read tools directly
• Orchestrator config changes → orchestrator session only
• Messages/notifications → use messaging tools directly
• Design decisions → orchestrator decides first, agent implements