efficient-frontier

name	efficient-frontier
description	Use when a frontier model (Fable, Opus, GPT-5.6) should delegate bounded research, coding, testing, or log reduction to cheaper models while keeping planning, synthesis, risk, and final review central. Owns usage-limit budgeting for agent waves.

Efficient Frontier

Read references/builder-upstream.md for the full workflow.

Use the expensive frontier model where marginal judgment matters. Push repeatable, bounded, or token-heavy work to cheaper/faster subagents.

Host gate: Claude-hosted workflows may apply the delegation rules below automatically. In native Codex, this skill does not authorize subagents by itself: work inline unless the user explicitly requests agents or invokes /swarm. Do not recursively invoke codex exec from Codex.

Model rankings

Rankings 1-10, higher better. Cost = what we actually pay, not list price. Intelligence = how hard a problem you can hand over. Taste = UI/UX, code quality, API design, design, copy.

Model	Cost	Intelligence	Taste
Fable-5	1	10	9
Opus-4.8	4	7	8
Sonnet-5	6	5	7
GPT-5.6 Sol (codex)	8	9	6
GPT-5.6 Terra (codex)	9	6	5
GPT-5.6 Luna (codex)	10	3	2

GPT-5.5 is retired. Variant floors are hard: Sol runs at medium|high effort only (all code writing and adversarial review -- smartest model rivaled only by Fable-5); Terra medium|high (budget non-code: PR comments, routine review passes, test-runner chores -- never product code); Luna high only (last resort for cheap tool-call loops far from code: tracker orchestration, test fixtures -- never development).

How to apply -- defaults, not limits. Standing permission to override: if a cheaper model's output does not meet the bar, rerun or redo on a smarter model WITHOUT asking. Judge the output, not the price tag; escalating costs less than shipping mediocre output.

• Anything that ships: intelligence > taste > cost. Cost is a tiebreaker only.
• Bulk mechanical (clear-spec implementation, data analysis, migrations): GPT-5.6 -- plan allowance, cheap relative to Claude tokens (not free; see /codex budget gate).
• User-facing (UI, copy, API design): taste >= 7 (Sonnet-5, Opus-4.8, Fable-5). Sol drafts, Claude finishes.
• Reviews and plans: Fable-5 or Opus-4.8, plus Sol as the independent cross-model perspective (Terra for routine re-check rounds).
• Cross-model review, automatic on every change: the author model never solely reviews its own work, and the reviewer comes from a DIFFERENT family whenever possible (family diversity catches shared blind spots). Claude authored -> Sol reviews; GPT authored -> Fable/Opus reviews; same-family clean-context only when the other family is unavailable (record it). Findings P0-P3 -> fixes delegated per routing, re-checked by the cross reviewer.
• Computer use and other token furnaces (browser verification, codebase analysis): shell to codex Sol and report back -- see /codex for variant routing (Sol/Terra/Luna + effort floors), exec/review mechanics, timeouts, worktree isolation, and wrapper labels.
• Fable-5 effort: high or lower only -- xhigh is token-hungry, max a furnace with worse output.
• Never use Haiku.

The frontier model is the brains: ambiguous decomposition, architecture/product/safety tradeoffs, integrating partial implementations, resolving conflicting subagent reports, final review. Do not delegate tiny tasks, tightly coupled blockers, or judgments that need the frontier model's full reasoning.

Workflow

1. Identify frontier-only decisions: architecture, prioritization, ambiguity resolution, risk, synthesis, final review.
2. Identify delegable work: repo inventory, docs extraction, source comparison, browser/testing passes, log clustering, narrow edits.
3. When delegation is authorized, spawn independent subagents with clear ownership, verification gates, and stop conditions; otherwise execute the same lanes inline.
4. Require compact evidence: findings, changed files, commands, residual risk, blockers.
5. Integrate centrally. Reopen high-risk cited files and inspect key diffs before claiming completion.

Guardrails

• Do not delegate the immediate blocker if the next local step depends on it.
• Do not ask multiple agents to edit the same files concurrently.
• Do not trust subagent conclusions blindly when risk is high.
• Do not claim universal savings; this works best when work parallelizes cleanly.

Usage limits (long or parallel waves)

1. Run bounded waves: at most 3 parallel subagents unless the user or host gives a throttle.
2. Let in-flight agents finish; do not interrupt them only to save budget.
3. Between waves, run /stay-within-limits (usage check, 95% pause rule, wake-to-resume) (Claude Code: bunx -y ccusage@latest blocks --active --json).
4. At or above 95% of either window: stop launching, prepare a self-contained resume (observed window, threshold, next safe check, remaining plan, exact rerun command).
5. On resume, re-check the real window before continuing.

For native Codex, use a real host meter or a user-reported dashboard value. If neither is available, usage is unknown: do not infer a percentage or reset time from session tokens. Run at most one explicitly requested wave, checkpoint, then ask before another wave.