Catalog
BuilderIO/efficient-orchestrator

BuilderIO

efficient-orchestrator

Run only when the user explicitly invokes /efficient-orchestrator (or the /efficient-frontier and /efficient-fable aliases). Keeps an expensive model (Fable, Opus, Astra, Sol) on planning, judgment and review while cheaper subagents do bounded research, coding, QA and log work. Never self-activate.

v1.0LATEST
NewUpdated Oct 29, 2026

Efficient Orchestrator

Use this only when the user asks for it by name. Without that request, do the work yourself and don't spawn helpers.

The expensive main model plans, decides, integrates and reviews. Cheaper subagents do the token-heavy, bounded work.

Model tiers

Main model Cheap helpers Use
Claude Fable / Opus haiku search, scans, docs extraction, log reduction, mechanical edits, test and browser runs
sonnet coding or analysis that needs judgment
OpenAI Astra / Sol gpt-6.1-terra low or medium coding, QA, research, most delegated work
gpt-6-luna bulk mechanical scans, only when Terra isn't needed

Set the model and effort explicitly on every spawn; never let a helper inherit the expensive model. If the main model is already a cheap tier, don't use this skill.

Workflow

  1. Keep at the top: architecture, prioritization, ambiguity, risk, synthesis and final review.
  2. Delegate: repo scans, research, narrow patches with clear file ownership, test and browser passes, failure clustering, log reduction.
  3. Write each handoff as a self-contained packet: repo path, objective, scope and out-of-scope, files or search targets, verification command, return format, stop conditions.
  4. Require compact returns: findings, changed files, commands run, evidence, open decisions.
  5. Inspect the evidence that matters before claiming done. Delegated output is evidence, not a verdict.

Limits

  • At most 3–5 helpers at once. Helpers never spawn their own helpers.
  • Close each helper as soon as its result is in.
  • Don't delegate the blocker your next step depends on, and never give two helpers the same files.
  • Stop helpers that return nothing usable twice; do that step yourself.
  • When done, say roughly how much work was delegated, so the cost is visible.
Files5
5 files · 238.8 KB

Select a file to preview

Overall Score

88/100

Grade

A

Excellent

Grades are signals, not a certification. Always review a skill yourself before use.

Safety

88

Quality

89

Clarity

88

Completeness

85

Summary

The efficient-orchestrator skill is a meta-agent instruction that manages cost-effective delegation of work to cheaper subagents when using expensive reasoning models (Fable, Opus, Astra, Sol). It keeps the expensive model focused on planning, judgment, and review while routing token-heavy, bounded tasks to cheaper tiers (Haiku, Sonnet, Terra, Luna). The skill is designed to activate only on explicit user invocation and includes strict guardrails against self-activation and excessive fan-out.

Detected Capabilities

agent spawningmodel tier selectionwork delegationoutput inspectioncost tracking

Trigger Keywords

Phrases that agents use to match this skill to user intent.

reduce token spenddelegate to subagentsexpensive model orchestrationmulti-agent coordinationcost-effective ai work

Use Cases

  • Reduce token spend by delegating research and mechanical tasks to cheaper models while keeping expensive models on planning and review
  • Coordinate multi-agent work on large projects by having the main model orchestrate and validate subagent outputs
  • Run cost-conscious complex projects that require both judgment (expensive) and bulk work (cheap)
  • Structure agent handoffs with clear scope, verification commands, and evidence review before integration

Quality Notes

  • Clear architectural guidance with explicit model tier mappings (Fable→Haiku/Sonnet, Astra→Terra/Luna)
  • Strong governance — maxes helpers at 3–5, forbids recursive spawning, requires explicit model/effort on every spawn
  • Well-documented handoff structure (repo path, objective, scope, verification, return format, stop conditions)
  • Practical constraints on delegation (don't delegate the blocker you depend on, close helpers when done)
  • Evidence-based verification before claiming completion is well-emphasized
  • Concise, action-oriented language with clear do's and don'ts
  • Includes aliases (/efficient-frontier, /efficient-fable) for discoverability
  • disable-model-invocation: true properly prevents self-activation
  • README diagram provides visual reinforcement of the delegation model
Model: claude-haiku-4-5-20251001Analyzed: Oct 29, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Use BuilderIO/efficient-orchestrator in your dev environment

Command Palette

Search for a command to run...