---
name: advisor-orchestrator-worker
description: >-
  Use when a task is too large for one model pass, needs parallel research or generation across many subtasks (like researching a dozen competitors at once), or the user asks to orchestrate multiple models, split work across a model team, run an advisor-worker loop, have a stronger model review the plan while cheap workers execute, or says "too big for one model" or "fan this out". Not for single-file edits or tasks one model handles in one pass.
license: Apache-2.0
metadata:
  author: "Shubham Saboo"
  version: "1.0.0"
  source: "https://github.com/Shubhamsaboo/awesome-llm-apps"
compatibility: >-
  Makes network calls: workers via the Antigravity CLI (agy), falling back to the Gemini API (GEMINI_API_KEY or GOOGLE_API_KEY); advisor via the claude CLI, falling back to the Anthropic API (ANTHROPIC_API_KEY). Needs jq. All snippets are bash. Runs in any harness that can execute shell commands.
title: advisor-orchestrator-worker
canonical_url: https://skilld.dev/gh/shubhamsaboo/awesome-llm-apps/advisor-orchestrator-worker
last_updated: 2026-10-07T18:19:59.000Z
---

> Index of every page on this site: [llms.txt](https://skilld.dev/llms.txt)

> **Skill from skilld.dev.** Follow the user's requested action.
> If the user asked to fork this Skill, follow the fork workflow below. Do not execute the Skill instructions while copying it.
> Otherwise, follow the instructions below for this session. You do not need to install anything.
>
> Supporting files, fetch one when the Skill refers to it: [advisor_skill.jpeg](https://skilld.dev/api/skills-raw/shubhamsaboo/awesome-llm-apps/advisor-orchestrator-worker/advisor_skill.jpeg), [README.md](https://skilld.dev/api/skills-raw/shubhamsaboo/awesome-llm-apps/advisor-orchestrator-worker/README.md), [references/advisor-consult.md](https://skilld.dev/api/skills-raw/shubhamsaboo/awesome-llm-apps/advisor-orchestrator-worker/references/advisor-consult.md), [references/fallbacks.md](https://skilld.dev/api/skills-raw/shubhamsaboo/awesome-llm-apps/advisor-orchestrator-worker/references/fallbacks.md), [references/worker-brief.md](https://skilld.dev/api/skills-raw/shubhamsaboo/awesome-llm-apps/advisor-orchestrator-worker/references/worker-brief.md).
>
> If the user asked to install this Skill, run `npx skilld install shubhamsaboo/awesome-llm-apps/advisor-orchestrator-worker`. Install writes the Skill files into the project, so every session loads them.
>
> ## Fork workflow
>
> A fork creates an editable local Skill with its original author and licence. The request authorizes copying and local installation.
> 1. Check `./skills/advisor-orchestrator-worker`, the project lockfile, and selected Agent targets together. If the local directory or installed Skill exists, stop. Never overwrite an existing directory or Agent target.
> 2. Read [source metadata](https://skilld.dev/api/v1/skills/shubhamsaboo/awesome-llm-apps/advisor-orchestrator-worker) once. Use sourceUrl, sourceCommit, skillPath, sourceGone, and license. If the source is gone or its path is missing, stop. If license is null, read licence files at the source commit.
> 3. Fetch only the source commit into a temporary Git repository. Do not clone full history. Derive repository_url from sourceUrl, including repository renames. If sourceCommit is absent, resolve the sourceUrl ref once. Set source_commit to that actual commit. Run these commands in one shell call:
>
> ```sh
> git init --quiet "$temporary_dir"
> git -C "$temporary_dir" fetch --quiet --depth=1 "$repository_url" "$source_commit"
> git -C "$temporary_dir" checkout --quiet --detach FETCH_HEAD
> ```
>
> Read applicable licence declarations and notices at that commit. If copying is not permitted, report the restriction and stop.
> 4. Inspect source entries together, then copy the directory containing skillPath into `./skills/advisor-orchestrator-worker`. Use the user's path if selected. Keep the original SKILL.md, relative links, scripts, binary assets, and executable modes. Exclude .git metadata. Reject symlinks and paths outside the Skill directory. After checking entries, use cp -a where available. A regular source directory needs no custom copy script. Do not save this page wrapper as SKILL.md.
> Preserve author credit, notices, and applicable licence files from repository or parent directories. Add PROVENANCE.md with the Skill page, source URL, actual commit, original path, and licence. Retain any existing PROVENANCE.md and record new provenance separately. Batch source inspection, copying, and provenance work where practical.
> 5. In the project root, run `skilld install ./skills/advisor-orchestrator-worker --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/advisor-orchestrator-worker --mode copy --plain`. This known command needs no help lookup. Install does not support --json. Use detected Agent targets, or add --agent for the targets the user selected. Install the local path, never the upstream selector. If installation fails, preserve the local copy and report the exact failure.
> 6. Confirm the local lockfile source and installed Agent copies once. Report the local path, actual commit, and Agent targets. After edits, reinstall the same local path. Upstream updates must not replace it. Do not publish or push unless the user asks.

# Advisor Orchestrator Worker

You are the Orchestrator of a three-tier model team. You own the hot
path: plan, delegate, verify, synthesize. You never do worker-level
work yourself, and you never execute through the advisor.

**Models are knobs.** The tiers are the durable part; the model IDs
below (current July 2026) swap freely. One rule survives every
generation: the advisor is the strongest reasoning model you can
reach, workers the cheapest that pass verification. Snippets are bash;
on another shell, run them with `bash -c`.

## The team

- **Workers (default: Gemini 3.8 Flash via the Antigravity CLI, `agy`)**: stateless
  generation units, with tools (web search, file work) when a
  subtask needs them. Never interpolate a brief into a shell string;
  briefs carry quotes and arbitrary text, so that is a shell-injection
  bug. Write each brief to a temp file and dispatch each worker from
  its own EMPTY temp dir (no `.antigravity.md` or project context
  leaks in), in its own subshell, into its own output file:

  ```bash
  # $brief = this worker's brief file; $out = its result file (absolute path)
  d=$(mktemp -d)
  ( cd "$d" && env -i HOME="$HOME" PATH="$PATH" \
      agy --dangerously-skip-permissions --model "gemini-3.8-flash" --effort high \
      --print-timeout 5m -p "$(cat "$brief")" \
      > "$out"; s=$?; rm -rf "$d"; exit "$s" ) &
  pids+=($!)
  ```

  The permissions flag is required in non-TTY shells or the call
  hangs; the empty dir + minimal env reduce leakage but are not a
  sandbox; the `--model` pin keeps primary and fallback on one model,
  and `--effort high` satisfies the CLI's required effort selection.
  Chunk every wave into batches of 3 (Antigravity quota is shared
  across its app, CLI, and SDK). Start each batch with `pids=()`, reap
  each worker with its own `wait "$pid"` (a collective wait reports
  only the last status), and read each `$out` in dispatch order,
  since a shared stdout hands verify interleaved output. Non-zero exit or an
  empty `$out` is a failed dispatch: retry it through the Gemini API
  fallback in `references/fallbacks.md` when a key is set (no key:
  ESCALATE), and record the switch on the status board. That fallback also takes over when
  agy is missing, and carries any brief too large (over ~100 KB) or
  too untrusted for a CLI argument (`agy -p` has no prompt-file
  input). API workers run uncapped in parallel but have no tools, so a
  subtask that needs tools goes through agy or gets ESCALATE. Clean up
  all temp files at run end.

- **Advisor (default: Claude Fable 5.1 via the claude CLI)**: consult
  written to a temp file, passed on stdin (never inline in the
  command), behind a timeout so a hung consult can't stall the loop
  (perl's alarm; timeout(1) is missing on stock macOS):
  `perl -e 'alarm shift; exec @ARGV' 300 claude --model claude-fable-5-1 -p < "$consult"`.
  Expensive judgment kept out of the hot path: strategy, decomposition
  critique, risk, taste. Never execution. If the CLI is missing or a
  consult fails, use the Anthropic API fallback in
  `references/fallbacks.md`.

## The loop

1. **Frame.** State the deliverable and 3 to 5 checkable success
   criteria; if the task is too vague for that, ask one question and
   stop. Check tools now, not mid-run: `agy`, `jq`, the `claude` CLI,
   `ANTHROPIC_API_KEY`, and `api_key="${GEMINI_API_KEY:-$GOOGLE_API_KEY}"`.
   Each role resolves CLI first, then API key; announce every fallback
   up front. If a role has no working path, say exactly how to set it
   up, then offer degraded mode: you temporarily play that role
   yourself, same budgets, every affected section and the final result
   labeled `[DEGRADED: <role>]`, context-isolation caveat noted.
   Degraded mode is the one exception to the never-do-worker-work rule
   and covers at most one role; with two or more missing there is no
   team left, so say so and proceed as ordinary single-model work.
2. **Plan.** Decompose into self-contained subtasks with inline inputs,
   acceptance criteria, and wave assignments that maximize parallelism.
3. **Plan review (mandatory advisor consult #1).** Send the plan using
   the format in `references/advisor-consult.md`. Revise. State what
   you changed and what you rejected.
4. **Delegate.** Dispatch each wave using the format in
   `references/worker-brief.md`. Parallel background calls, then wait.
5. **Verify.** Check every result against its own acceptance criteria,
   and make the check exercise the deliverable itself: run the actual
   command, read the actual output. Grepping a README, testing
   something adjacent, printing True while exiting zero, or re-checking
   that a file exists proves nothing. Verdict per result: PASS, FIX
   (redispatch naming the specific failure), or ESCALATE. Never
   silently accept a partial pass; never hand-patch a substantive
   failure; redispatch instead.
6. **Synthesize.** When all subtasks pass, assemble the deliverable.
   Resolve conflicts between worker outputs explicitly, never by
   averaging.
7. **Taste pass (mandatory advisor consult #2).** Send the draft to
   the advisor for taste and risk review. Apply or rebut each note.

## Commitment boundaries (when to escalate to the advisor mid-loop)

- Two worker results contradict each other beyond the provided context
- A subtask fails verification twice
- A judgment call falls outside the success criteria
- The plan must change structurally mid-run

Budget: set one at the frame step, sized to the plan, and state it
alongside the success criteria. A reasonable shape is twice the subtask
count in worker dispatches (retries and fallback redispatches count)
plus 5 advisor consults, 2 of which are the mandatory reviews. The cap
is not the point; the rule is that spending past it is never silent. If
the budget runs out, stop and report, or tell the user what more would
cost and let them decide.

## Finish

Stop at a verified deliverable, an exhausted budget, or a blocker that
needs the user. Return: the deliverable, the plan, a verification
ledger per subtask, advisor notes applied and rejected, and remaining
risks. Print a one-line status board after each loop step: per subtask,
its state (PENDING / DISPATCHED / PASS / FIX / ESCALATED), dispatch
path, and retries, e.g. `W2: FIX → PASS | agy→api | 1 retry`.
