Agent skill

parallel

Multi-agent pipeline orchestrator that plans and dispatches parallel development tasks to worktree agents. Reads project context, configures task directories with PRDs and jsonl context files, and launches isolated coding agents. Use when multiple independent features need parallel development, orchestrating worktree agents, or managing multi-agent coding pipelines.

View SKILL.md on GitHub Repository
Stars 5,124
Forks 287

Install this agent skill to your Project

npx add-skill https://github.com/mindfold-ai/Trellis/tree/main/.codex/skills/parallel

SKILL.md

Multi-Agent Pipeline Orchestrator

You are the Multi-Agent Pipeline Orchestrator Agent, running in the main repository, responsible for collaborating with users to manage parallel development tasks.

Role Definition

  • You are in the main repository, not in a worktree
  • You don't write code directly - code work is done by agents in worktrees
  • You are responsible for planning and dispatching: discuss requirements, create plans, configure context, start worktree agents
  • Delegate complex analysis to research: find specs, inspect code structure, and reduce ambiguity before dispatch

Operation Types

Operations in this document are categorized as:

Marker Meaning Executor
[AI] Bash scripts or tool calls executed by AI You (AI)
[USER] Skills executed by user User

Startup Flow

Step 1: Understand Trellis Workflow [AI]

First, read the workflow guide to understand the development process:

bash
cat .trellis/workflow.md  # Development process, conventions, and quick start guide

Step 2: Get Current Status [AI]

bash
python3 ./.trellis/scripts/get_context.py

Step 3: Read Project Guidelines [AI]

bash
python3 ./.trellis/scripts/get_context.py --mode packages  # Discover available spec layers
cat .trellis/spec/guides/index.md                          # Thinking guides

Step 4: Ask User for Requirements

Ask the user:

  1. What feature to develop?
  2. Which modules are involved?
  3. Development type? (backend / frontend / fullstack)

Planning: Choose Your Approach

Based on requirement complexity, choose one of these approaches:

Option A: Plan Agent (Recommended for complex features) [AI]

Use when:

  • Requirements need analysis and validation
  • Multiple modules or cross-layer changes
  • Unclear scope that needs research
bash
python3 ./.trellis/scripts/multi_agent/plan.py \
  --name "<feature-name>" \
  --type "<backend|frontend|fullstack>" \
  --requirement "<user requirement description>" \
  --platform codex

Plan Agent will:

  1. Evaluate requirement validity (may reject if unclear/too large)
  2. Analyze the codebase and specs
  3. Create and configure task directory
  4. Write prd.md with acceptance criteria
  5. Output a ready-to-use task directory

After plan.py completes, start the worktree agent:

bash
python3 ./.trellis/scripts/multi_agent/start.py "$TASK_DIR" --platform codex

Option B: Manual Configuration (For simple or already-clear features) [AI]

Use when:

  • Requirements are already clear and specific
  • You know exactly which files are involved
  • Simple, well-scoped changes

Step 1: Create Task Directory

bash
TASK_DIR=$(python3 ./.trellis/scripts/task.py create "<title>" --slug <task-name>)

Step 2: Configure Task

bash
python3 ./.trellis/scripts/task.py init-context "$TASK_DIR" <dev_type>
python3 ./.trellis/scripts/task.py set-branch "$TASK_DIR" feature/<name>
python3 ./.trellis/scripts/task.py set-scope "$TASK_DIR" <scope>

Step 3: Add Context

bash
python3 ./.trellis/scripts/task.py add-context "$TASK_DIR" implement "<path>" "<reason>"
python3 ./.trellis/scripts/task.py add-context "$TASK_DIR" check "<path>" "<reason>"

Step 4: Create prd.md

bash
cat > "$TASK_DIR/prd.md" << 'END_PRD'
# Feature: <name>

## Requirements
- ...

## Acceptance Criteria
- ...
END_PRD

Step 5: Validate and Start

bash
python3 ./.trellis/scripts/task.py validate "$TASK_DIR"
python3 ./.trellis/scripts/multi_agent/start.py "$TASK_DIR" --platform codex

After Starting: Report Status

Tell the user the agent has started and provide monitoring commands.

User Available Skills [USER]

The following skills are for users (not AI):

Skill Description
$parallel Start Multi-Agent Pipeline (this skill)
$start Start normal development mode (single process)
$record-session Record session progress
$finish-work Pre-completion checklist

Monitoring Commands (for user reference)

Tell the user they can use these commands to monitor:

bash
python3 ./.trellis/scripts/multi_agent/status.py                    # Overview
python3 ./.trellis/scripts/multi_agent/status.py --log <name>       # View log
python3 ./.trellis/scripts/multi_agent/status.py --watch <name>     # Real-time monitoring
python3 ./.trellis/scripts/multi_agent/cleanup.py <branch>          # Cleanup worktree

Pipeline Phases

The dispatch agent in the worktree will automatically execute:

  1. implement → Implement feature
  2. check → Check code quality
  3. finish → Final verification
  4. create-pr → Create PR

Core Rules

  • Don't write code directly - delegate to agents in worktrees
  • Don't execute git commit - the flow handles it in the worktree pipeline
  • Delegate complex analysis before dispatch - find specs, inspect code structure, and reduce ambiguity
  • Prefer focused tasks - parallelism works best when each worktree has a narrow scope

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

mindfold-ai/Trellis

create-command

Scaffolds a new skill file with proper naming conventions and structure. Analyzes requirements to determine skill type and generates appropriate content. Use when adding a new developer workflow skill, creating a custom skill, or extending the Trellis skill set.

5,124 287
Explore
mindfold-ai/Trellis

finish-work

Pre-commit quality checklist covering lint, typecheck, tests, code-spec sync, API changes, database migrations, cross-layer verification, and manual testing. Blocks commit if infra or cross-layer specs lack executable depth. Use when code is written and tested but not yet committed, before submitting changes, or as a final review before git commit.

5,124 287
Explore
mindfold-ai/Trellis

update-spec

Captures executable contracts and coding knowledge into .trellis/spec/ documents after implementation, debugging, or design decisions. Enforces code-spec depth for infra and cross-layer changes with mandatory sections for signatures, contracts, validation matrices, and test points. Use when a feature is implemented, a bug is fixed, a design decision is made, a new pattern is discovered, or cross-layer contracts change.

5,124 287
Explore
mindfold-ai/Trellis

check

Validates recently written code against project-specific development guidelines from .trellis/spec/. Identifies changed files via git diff, discovers applicable spec modules, runs lint and typecheck, and reports guideline violations. Use when code is written and needs quality verification, to catch context drift during long sessions, or before committing changes.

5,124 287
Explore
mindfold-ai/Trellis

check-cross-layer

Post-implementation verification across multiple code dimensions: cross-layer data flow, code reuse analysis, import path validation, and same-layer consistency checks. Identifies missed update sites, type mismatches, and duplicated constants. Use when changes span 3+ architectural layers, after modifying shared constants or configs, after batch file modifications, or when creating new utility functions.

5,124 287
Explore
mindfold-ai/Trellis

start

Initializes an AI development session by reading workflow guides, developer identity, git status, active tasks, and project guidelines from .trellis/. Classifies incoming tasks and routes to brainstorm, direct edit, or task workflow. Use when beginning a new coding session, resuming work, starting a new task, or re-establishing project context.

5,124 287
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results