Pilot Task Chain

Chain tasks into sequential pipelines across agents. Use this skill when: 1. You need multi-step workflows where each step depends on previous results 2. You...

Security Scan

The skill is an instruction-only orchestration helper that coherently relies on pilotctl; the main issues are minor metadata/instruction mismatches (jq and agent-env vars are referenced but not declared) and standard privacy considerations when passing data between agents.

Purpose & Capability

The skill's stated purpose (chaining tasks across agents) matches the instructions and the only required binary explicitly declared (pilotctl). The SKILL.md also documents the pilot-protocol dependency and use of pilotctl as expected for an orchestration/orchestration tool.

Instruction Scope

Instructions are limited to submitting tasks, polling for completion, extracting results, and submitting subsequent tasks via pilotctl. They do not request unrelated system files or credentials. However, the examples assume environment variables such as AGENT_1, FETCH_AGENT, TRANSFORM_AGENT, and STORE_AGENT exist — these are not declared in the registry metadata and could cause confusion at runtime.

Install Mechanism

This is an instruction-only skill with no install spec or code to write to disk, which is the lowest-risk install mechanism. No external downloads or package installs are invoked from SKILL.md.

Credentials

The skill does not require credentials or config paths, which is proportionate. That said, SKILL.md references jq (and relies on it in examples) but jq was not listed in the registry's required binaries — a minor inconsistency. Also the examples expect agent-identifying env vars that are not declared as required env; these should be documented so users know to provide them.

Persistence & Privilege

The skill does not request persistent/always-on privileges (always: false). It does not attempt to modify other skills or system-wide config in the instructions.

Assessment

This skill is instruction-only and generally coherent for chaining pilot-protocol tasks, but before installing you should: 1) Ensure pilotctl on PATH and the pilot daemon are from a trusted source (verify versions/signatures) and run pilotctl daemon start as directed. 2) Install jq (examples use it) and ensure bash is available. 3) Provide the agent name variables used in examples (e.g., FETCH_AGENT, TRANSFORM_AGENT, STORE_AGENT or AGENT_1) — these are not declared in the registry metadata. 4) Be mindful that intermediate results are passed between agents; do not send sensitive secrets or private data through these pipelines unless you trust all participating agents and the pilot-protocol environment. 5) Confirm you trust the pilot-protocol skill/homepage and the AGPL-3.0 license implications. If you need higher assurance, ask the publisher to update registry metadata to list jq and required env vars explicitly and to provide a reproducible provenance for pilotctl.

Chain tasks into sequential pipelines where each step's output becomes the next step's input.

Commands

Submit first task

pilotctl --json task submit "$AGENT_1" --task "Fetch data from https://api.example.com/data"

Wait for completion

TASK_ID="abc123"
while true; do
  STATUS=$(pilotctl --json task list --type submitted | jq -r ".[] | select(.task_id == \"$TASK_ID\") | .status")
  [ "$STATUS" == "completed" ] && break
  sleep 2
done

Extract result and submit next task

RESULT=$(pilotctl --json task list --type submitted | jq -r ".[] | select(.task_id == \"$TASK_ID\") | .result")

pilotctl --json task submit "$AGENT_2" --task "Transform data: $RESULT"

Workflow Example

Three-step pipeline (Fetch -> Transform -> Store):

#!/bin/bash
# Step 1: Fetch
FETCH_TASK=$(pilotctl --json task submit "$FETCH_AGENT" \
  --task "Fetch data from API endpoint")
FETCH_TASK_ID=$(echo "$FETCH_TASK" | jq -r '.task_id')

while [ "$(pilotctl --json task list --type submitted | jq -r ".[] | select(.task_id == \"$FETCH_TASK_ID\") | .status")" != "completed" ]; do
  sleep 2
done

FETCH_RESULT=$(pilotctl --json task list --type submitted | jq -r ".[] | select(.task_id == \"$FETCH_TASK_ID\") | .result")

# Step 2: Transform
TRANSFORM_TASK=$(pilotctl --json task submit "$TRANSFORM_AGENT" \
  --task "Transform data: $FETCH_RESULT")
TRANSFORM_TASK_ID=$(echo "$TRANSFORM_TASK" | jq -r '.task_id')

while [ "$(pilotctl --json task list --type submitted | jq -r ".[] | select(.task_id == \"$TRANSFORM_TASK_ID\") | .status")" != "completed" ]; do
  sleep 2
done

TRANSFORM_RESULT=$(pilotctl --json task list --type submitted | jq -r ".[] | select(.task_id == \"$TRANSFORM_TASK_ID\") | .result")

# Step 3: Store
STORE_TASK=$(pilotctl --json task submit "$STORE_AGENT" \
  --task "Store data: $TRANSFORM_RESULT")

echo "Pipeline completed: $(echo "$STORE_TASK" | jq -r '.task_id')"

Dependencies

Requires pilot-protocol skill, jq, and multiple agents with complementary capabilities.