orchestrate-agents
/orchestrate-agents
Koordynuje pracę projektową między Codex, Claude Code i Google Antigravity: dobiera modele, wznawia czaty i śledzi postępy.
- Autor
- danielyaa5 ↗
- Repozytorium
- orchestrate-agents ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 11.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 15
- Skrypty
- 9
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 1
Brak sygnałów. Repozytorium zmienione 11.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
- 9 skryptów w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
Skrypty: scripts/claude_worker.py, scripts/google_worker.py, scripts/isolation.py, scripts/provider_chat.py, scripts/verification.py, tests/test_isolation.py, tests/test_sessions.py, tests/test_verification.py
Co robi i kiedy
Koordynuje pracę projektową między Codex, Claude Code i Google Antigravity: dobiera modele, wznawia czaty i śledzi postępy.
Oryginalny opis (EN)
Coordinate project work across Codex, Claude Code and Google Antigravity. Use for model and effort routing, starting or resuming provider chats, coordinating implementers and independent reviewers, or tracking verified progress on large tasks.
Jak działa
- Coordinator availability (never block the communication channel)
- Decide who should do the work
- Start, continue and find the actual chat
- Show progress on large tasks
- Verify, report and improve
Podgląd SKILL.md
--- name: orchestrate-agents description: Coordinate project work across Codex, Claude Code and Google Antigravity. Use for model and effort routing, starting or resuming provider chats, coordinating implementers and independent reviewers, or tracking verified progress on large tasks. --- # Coordinate agents across providers Own the outcome while keeping the coordinator chat fast, conversational, and available as the user's live communication channel. Delegate to an existing owner when continuing the same subject/outcome (or when the platform supports renaming its title as focus shifts). Spawn a fresh worker when the work has a distinct outcome, needs different tools/access/judgment, or runs on a title-locked subagent surface. A small task often needs just one worker. Answer direct status/decision questions, advice requests, or copy-ready handoffs from evidence already in hand. ## Coordinator availability (never block the communication channel) The coordinator chat is the user's primary live means of communication and must stay responsive at all times; running multi-step tool chains inline ties up the coordinator turn and makes it unavailable to talk. - **Limit inline coordinator work** to reading the coordinator status/handoff record, checking quota/model availability when routing, dispatching or messaging workers, and answering direct status or decision questions from evidence already in hand (at most an instant single check when needed to route). - **Delegate pre-implementation work too.** Hand read-only codebase exploration, root-cause investigation, environment/device/log inspection, and plan drafting to a work chat or background subagent — **including when the user asks to see a plan before implementation** (for example, `"tell me the plan once you decide"`). Instruct the worker to stay strictly read-only (no code or state edits) and return exact file/line findings plus a decision-complete plan. - **Return control immediately.** Give the user an immediate brief handoff with the clickable chat/conversation link so the coordinator chat stays open while the worker runs, then relay the finished plan (for approval) or verified result when the worker completes. - **Tag every worker link with inline `(Model · Effort)`.** Every subagent, swarm worker, or provider work-chat link in handoffs, progress updates, and final replies must display its active **model and effort** inline — either inside the Role/link label (for example, `[Savings Investigator (Carbon · High)](conversation://...)` or `[Savings Investigator · Carbon High](conversation://...)`) or immediately beside the link (for example, ``[Savings Investigator](conversation://...) (`Carbon · High`)`` / ``(`Opus 5.5 · High`)``). For `invoke_subagent` with `Model: "inherit"`, state the concrete inherited model and effort when known (or `inherit` + tier if the host does not expose the exact parent slug) rather than making the user click into the subchat pane to check. - **Keep worker tab and chat titles truthful (never recycle title-locked subagents across phases).** At meaningful handoffs, changes of focus, or new rounds with a distinct outcome, update the worker's title when the platform supports renaming (`swarm(action: "title")`, Codex/Claude desktop chat title controls, etc.). **When a platform locks a subagent's UI title/`Role` at creation (like Antigravity `invoke_subagent`), never recycle an older subagent for a new subject or outcome** — spawn a fresh subagent with an up-to-date `Role` + `(Model · Effort)` title and pass the 2–3 lines of needed context in its prompt so every tab header reflects what that worker is actually doing right now. ## Decide who should do the work 1. Identify the deliverable, the current owner, what may change, the evidence that will settle the task, and any dependencies. Read the relevant project notes and current chat/status before assigning duplicate work. 2. Check live subscription headroom (for example [AI Usage](https://github.com/danielyaa5/ai-usage) `summary-today.json` snapshots) and offered models (`agy models`, `codex debug models`), then choose the provider, exact available model, and supported effort yourself. Avoid depleted buckets (for example `left_pct <= 5` or `critical`), and compare Antigravity's `"Claude and GPT models"` pool against direct Claude Max before dispatching Claude: for Claude Opus/Sonnet at `high` effort or lower (`low`, `medium`, `high`), prefer Antigravity (`--provider google --model claude-opus-5-5-*` / `claude-sonnet-5-5-*`) whenever that pool has healthy headroom ahead of or comparable to direct Claude Max; reserve direct `--provider claude` for `xhigh`/`max` effort, models absent from `agy models`, existing `--provider claude` resumes, or when Antigravity's Claude pool is tighter than direct Claude Max. Weigh the kind of task, consequence of an error, uncertainty, recent performance on comparable work, included usage remaining, and cost of handing over context. For planning workers, apply the **Planning model and effort selection** rules below; when two effort levels fit an ambiguous or high-risk task, choose the higher; for bounded mechanical steps backed by `--verify-cmd`, use the token-lean tier in the [routing guide](references/routing.md). Honor explicit provider or model choices. 3. Give the worker the relevant input, its allowed workspace or file scope, expected behavior, and a way to demonstrate success. Have discovery return exact target and test file paths so subsequent edits can pass `--include-path` instead of re-grepping the whole repository. For an editor, name the repro and test that must go from failing to passing. For an independent reviewer, provide the artifact and failure condition while leaving it room to find a different explanation; gate a separate LLM QA session to destructive, stateful, billing, auth, migration, or concurrency changes while letting host `--verify-cmd` plus coordinator diff review settle routine deterministic fixes. 4. Name one integrator for the live candidate. Run independent editors in parallel with `--mode edit --isolate apfs` (plus `--include-path` whenever the file set is known), even when the candidate is dirty. Give each a separate receipt, a narrow scope, and a quiet coordinator-owned `--verify-cmd` (such as `pytest -q --tb=short`, `python3 -B -m unittest`, `swift test -q`, or `xcodebuild -quiet`). The verifier runs on the host; provider shell tools remain disabled. Route overlapping changes to the integrator explicitly. Direct edits to the same live files still need a handback. Transfer the repro, results, exact source state, and remaining risks when the editor changes. Device or account operators own their live session until they hand it back. ### Planning model and effort selection - **Highest-intelligence model among healthy quota pools:** Subagents and work chats starting planning tasks default to the **highest-intelligence model available among providers/pools with healthy remaining quota before reset**, unless it is very clear a lighter model suffices. Always check live usage and reset headroom first (`summary-today.json`, Antigravity model quotas / `agy models`, `provider_chat.py` / Codex limits): if one top-tier model or pool (for example direct Claude/`Fable 5.2` or Codex) is low ahead of its weekly reset, route planning to an equally top-tier model with healthy headroom (such as `Gemini 4 Carbon (High)` or Antigravity `Claude Opus 5.5 (High)`) rather than draining a scarce pool. - **Three-rung planning effort ladder (never use `Low` for planning subagents):** Overshoot rather than undershoot when uncertain — pick `High` when between `Medium` and `High`, and pick `Max`/`xhigh` when between `High` and `Max`/`xhigh`: - **`High` (default for real planning tasks):** Multi-file changes, state/ranking logic, UX trade-offs, or competing requirements — fast enough not to stall plan approval, deep enough to catch cross-file traps upfront (and for Claude Opus, `<= high` uses Antigravity quota first when that pool has healthy headroom). - **`Max` / `xhigh` (high-stakes, irreversible, or repeat bugs):** Plans touching destructive or irreversible data safety, billing/entitlements, migrations, auth/security/sync, or bugs that survived a prior fix. - **`Medium` (only when certainty is already very high):** Small, localized, reversible UI/copy/wiring plans where the files and invariants are already well understood. ### Host- and quota-aware parallelization playbook Avoid redundant or duplicate workers on the same slice, while actively fanning out independent work to cut wall-clock turnaround: 1. **Always fan out independent read-only investigations and verification tracks in parallel:** - When multiple bugs, questions, or unknowns arrive, dispatch parallel read-only subagents/subchats immediately rather than investigating serially. - Once implementation is ready, run independent verification tracks **concurrently** rather than back-to-back (for example, iOS Simulator/UI tests + Mac Playwright/Python/bash suites + independent cross-family review running at the same time). 2. **Parallel writers require workspace isolation AND disjoint file boundaries:** - When a task spans non-overlapping files or subsystems (for example, `stats.html`/`index.html` vs. `ios/*.swift`, or separate modules/docs), split across 2–3 isolated writers (`Workspace: "share"` / `"branch"` on Antigravity subagents, or `--isolate apfs` / git worktrees on `provider_chat.py` subchats) with explicit file-ownership boundaries, then integrate/merge cleanly before final QA. - When multiple changes tightly touch the **same functions or files** (such as intertwined state logic in a single file), keep a single writer to avoid merge conflicts and semantic drift. 3. **Scale concurrency to host hardware and quota headroom:** - On high-core workstations (for example Apple Silicon Max/Ultra desktops) paired with healthy quota pools (such as `Gemini 4 Carbon` or Antigravity `Claude Opus` when healthy), default to wider parallelism (`2–4` concurrent workers/test suites) so wall-clock turnaround drops sharply instead of leaving cores idle during LLM think/wait cycles. - Stay narrower (`1–2` concurrent heavy builds/runners) on memory- or thermally constrained laptops/servers, or when operating on scarce weekly quota pools before reset. ## Start, continue and find the actual chat - **Codex.** When Codex quota is healthy and Codex owns the work, use the supported chat tools to locate the existing project owner and send or resume authorized work. For a new user-visible chat, follow the host tool's creation and model-override rules. Use task-scoped agents for authorized internal delegation. Confirm an override on the actual new turn when the exact model matters. A steering message to an active turn can leave its existing model in charge. A requested change of model can take effect at the next idle turn without stopping work in flight. Read history/status through supported tools or the saved transcript. - **Google or Claude.** Use the signed-in provider CLI (`agy` or `claude`) on the host that owns the authorized workspace; `--provider google` also drives Antigravity-hosted Claude (`claude-opus-5-5-*`, `claude-sonnet-5-5-*`) and OSS models when listed by `agy models`. [Provider chats](references/provider-chats.md) gives a working start/resume command; run `provider_chat.py` outside any outer `sandbox-exec` wrapper so host verification can apply its own macOS seatbelt profile. Save the provider session ID, host, workspace and latest reply in a private record so a different coordinator (on Codex, Claude, or Antigravity) can pick it up. Rely on `provider_chat.py`'s compact stdout summary during coordination and run `show --record` only when full diagnostics are needed. - **Coordinator rotation.** Use one file named `<Project> Coordinator Status.md` in the project's private handoff/notes folder (for example its private Codex documents folder). Keep its path stable across dates and across coordinator providers (Codex, Claude, or Antigravity). Link it once from the project's durable private working notes, and in coordinator handoffs. Reuse the same board on rotation. At takeover read this file first, then fetch only the referenced receipt or owner update needed for the next action. Keep the current state on the board and long evidence in linked reports. The coordinator or named delegate updates the board on dispatch, patch delivery, integration, QA signoff, a changed approval or release state. Include: - **Owners:** linked current Codex titles, role, active dependency, next actor; include provider/model/effort and exact private launcher record path for each running or resumable external worker. Distinguish older standalone sessions without launcher records. - **Candidate:** live uncommitted source revision or fingerprints, changes actually integrated, and what is installed. - **Isolated patches:** source baseline or receipt, touched files, patch link/digest and local verification outcome. Mark awaiting integration, superseded, or integrated at an exact revision. A verified local patch is still staged until the integrator applies it. - **Next and approvals:** independent QA outstanding or passed on which build, human/device blockers, and actions awaiting user approval; keep prior approvals scoped. Include a last-updated time in the project's timezone. - **Scope.** Carry the user's authorization across the handoff. Share the selected brief and necessary inputs with the selected provider. Keep private notebooks, credentials, personal media and unrelated changes outside its workspace. Preserve foreground focus and normal approval boundaries for real sends, purchases, data removal or release submissions. When the user asks only for a provider opinion, the existing consultation skills support that narrower workflow. ## Show progress on large tasks When work spans several owners, stages, or a long-running batch, give the user a short progress snapshot **in the coordinator chat** without waiting for them to ask. Establish the baseline at kickoff or takeover. Keep the same snapshot near the top of the existing private coordinator status file. A quick single-owner task can use a plain result. - Pick a few counts that answer what the user is waiting for. Name the unit, define what earns completion, and use the agreed scope as the denominator. For a rollout, verified fixes, platform checks, and requested installs can each have their own count. Use counts for a named phase when the overall scope is still open. If a total is unknown, report what is verified and what remains to be scoped. - Ask each owner to return the completed units, remaining or blocked units, build or scope, and evidence with their normal milestone report. Count each unit once. A retry, second reporter, or larger test suite for the same outcome adds evidence. A passing staged patch, integrated fix, independent signoff and actual install earn credit only in their respective stages. Reopen affected units when a new build requires a retest. If scope changes, show the old and new totals and the reason. - On a meaningful change, include the new counts, what moved since the previous update, and the next milestone with its linked owner. Surface any critical blocker or specific action the user must take even if most checks passed. Batch related owner updates. During long work follow the existing update cadence; when asked for status, report the latest verified counts immediately. Give a time estimate only when observed throughput or a bounded remaining step supports it. - Use a few lines or a small table, with the build or measurement window when it matters. For example, “Device runs on build 11: 1/2 complete (+1 Mac). Independent signoff: 0/1, blocked by the deletion case. Personal installs: 0/3. Next: the repair owner hands the new build to QA.” Use a percentage only for a defined, comparable set of units; unrelated tests, milestones and installs do not share a meaningful percentage. ## Verify, report and improve For isolated work, the integrator reviews the patch and its touched files, checks it against the current live checkout, then applies it and reruns the scoped check on the combined candidate. Independent QA verifies that combined revision. If the baseline has drifted, resolve the change with its owner; never overwrite unrelated edits. See [verification and integration commands](references/provider-chats.md#verified-isolated-edits). A provider reply establishes that the worker answered. Inspect the artifact, test result, or actual changed flow before calling the task complete. For consequential changes, give a distinct tester the same frozen source and exercise both a safe success and the failure to prevent. Capture the right boundary: an intercepted request can prove it was attempted; a compiled app still needs a device run to prove its behavior. Return the chat link (tagged inline with its `Model · Effort`) and the concrete next owner promptly. Keep tracking accepted work. Report a meaningful verified outcome, a changed decision, or an actual human blocker; batch repeated acknowledgments in the project record. Check the latest response and mark a managed Codex chat read after relaying it, preserving newer unreported messages. Distinguish findings, source edits, tested builds, and installs. On a failed worker turn check for partial edits before retrying or switching provider. Keep this skill small as it evolves. Update the routing examples when a real project changes the recommendation. Record the task, model/effort, rework or acceptance result, and why the choice changed. Keep project-specific receipts and running queues in the project's private handoff. When updating the launcher, run all offline regressions from the skill folder with `python3 -B -m unittest discover -s tests` on the Mac. They exercise receipt recovery, isolated patches, host checks and same-session retries. For a provider adapter change, also start and resume a disposable live conversation and verify the second turn recalls something supplied only in the first. An unchanged session ID by itself did not prove continuity in Antigravity print mode.
Pliki w paczce (15)
- .gitignore 1 KB
- LICENSE 1 KB
- README.md 6 KB
- SKILL.md 18 KB
- references/provider-chats.md 12 KB
- references/routing.md 7 KB
- scripts/claude_worker.py 6 KB
- scripts/google_worker.py 12 KB
- scripts/isolation.py 27 KB
- scripts/provider_chat.py 16 KB
- scripts/verification.py 9 KB
- tests/test_isolation.py 17 KB
- tests/test_sessions.py 9 KB
- tests/test_verification.py 10 KB
- tests/test_verified_turns.py 7 KB
Wersje
W bazie nie ma innych skilli o nazwie orchestrate-agents.
Migawka bazy z 13.11.2026 · wersja paczki 3d3cf0590335 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100codex-orchestrate
Orkiestruje w Claude Code duży plan wieloetapowy, delegując implementację do Codex CLI przez agents-bridge, po poleceniu /codex-orchestrate. - 90delegate
Przekazuje pracę innym agentom kodującym, takim jak Claude Code, Codex czy Antigravity, i koordynuje ich uruchomienia równolegle. - 90Codex Integration
Deleguje złożone zadania kodowe do Codex CLI i koordynuje pracę między Claude a Codex. - 100orchestrate
Planuje pracę w strumieniach, sprawdza zależności i koordynuje zatwierdzone przez użytkownika wykonanie przez subagentów Codex, jako odpowiednik polecenia /orchestrate z Claude Copilot. - 100orchestrate
Prowadzi wdrożenie w kilku wycinkach z osobnymi agentami implementującymi i recenzującymi w panelach tmux. - 90claude2antigravity
Przenosi umiejętności, wtyczki, agentów, serwery MCP i rozmowy z Claude Code do Google Antigravity, by pracę dało się kontynuować po limicie.