Don't Make the Expensive Model Do Everything — delegate-skills, a Casual Multi-Model Setup Built on Nothing but Standard Skills

Putting a top-tier model like Claude Fable 5 in charge of your main agent raises the quality of its judgment — but it also means paying flagship prices for "labor": reading piles of code, applying mechanical fixes, staring at diffs. Fable 5 costs $10 input / $50 output (per 1M tokens). Claude Haiku 4.5, meanwhile, is $1 / $5.

Do you really need to pay 10× the rate for grunt work?

As it happens, Anthropic itself has answered this question. According to a post from @ClaudeDevs, a Claude Managed Agents configuration that splits Fable 5 into the planner/integrator role (orchestrator) and Sonnet 5 into the read-and-execute role (worker) achieved 96% of standalone Fable 5's performance at 46% of the price on the BrowseComp web-research benchmark. This "plan with a big model, execute with small models" pattern is covered in detail in the official cookbook Plan big, execute small.

delegate-skills is a skill set that brings this same idea to the world of CLI agents like Claude Code — using nothing but the standard skill mechanism. Your main agent stays on the expensive model, while exploration, implementation, review, and chores are delegated to child processes running cheaper models (or models from other vendors), compressing your token costs.

What you get

1. Token-cost compression

Routine read/write-heavy work is offloaded to cheap models, so an expensive model like Fable spends its tokens on decision-making and final responsibility. Delegate code exploration to Haiku via the delegate-explore skill, for example, and the token unit price of that work drops to 1/10.

2. Context isolation

Delegation isn't only about cost. Bulk file reads and trial-and-error logs stay confined to the child process; the main agent reads the result markdown progressively — index first, then only the sections it needs. Because the main conversation context never bloats with investigation logs, the quality of its judgment holds up even in long sessions.

3. Crossing vendor walls

Delegation targets are not limited to the Claude family. Just specifying a model name selects the execution backend.

Model name	Backend	Launched via
sonnet / haiku / opus / fable	Claude subprocess	claude -p
gpt-*	Codex subprocess	codex exec
swe-* / devin-*	Devin CLI subprocess	devin -p
composer-* / cursor-*	Cursor agent CLI subprocess	agent -p

Throwing an implementation at GPT from Claude Code, or an exploration at Haiku from Codex — cross-vendor delegation works through a single mechanism. The requesting side (the main agent) can also be any of Claude Code / Codex / Devin CLI / Cursor CLI.

The skill lineup

Skill	Purpose	Tool permissions	Default model
delegate-explore	Read-only code & documentation exploration	read-only	haiku
delegate-implement	Code implementation & fixes (one commit)	Edit/Write/Bash (no push)	sonnet
delegate-chore	Fallback miscellaneous work	Edit/Write/Bash (no push)	haiku
delegate-review	Code / document review (surfacing findings on a diff)	read-only	opus

Each skill's default model can be changed via an environment variable, DELEGATE_<TYPE>_MODEL (e.g. DELEGATE_IMPLEMENT_MODEL=gpt-5.5).

How it differs from similar efforts

Attempts to combine multiple models are multiplying right now: LLM routers that pick a response model per query, dedicated orchestration frameworks, and the first-party multi-agent features that each agent CLI is starting to ship. delegate-skills sits in this same current, but its position is distinct.

Standard skills only — and casual about it

The biggest differentiator is that everything runs on the agent's standard skill mechanism alone. No dedicated server, no resident process, no SQLite, no orchestration framework to adopt. Since the substance is just shell scripts and a file-based protocol, it works the moment you gh skill install it — and when you no longer need it, you just uninstall. Getting started isn't the major undertaking of "building a multi-model architecture"; it's as casual as adding one more skill.

vs. Claude Code's built-in multi-agent sessions

Claude Code ships with a built-in multi-agent session mechanism. delegate-skills is not a replacement for it — the aims differ.

• Token-cost efficiency is the top priority — where most general-purpose multi-agent mechanisms center on parallelism or role separation, delegate-skills is designed first and foremost to "offload to cheap models and shrink the bill." The cheap-model defaults, progressive reading via md2idx, and measured costs in the observe JSON all serve this goal
• The only topology is a tree from a single parent — agents don't talk to each other as peers; delegation always flows one way, parent → child, and a recursion guard prevents runaway chains. By deliberately limiting expressiveness, both accountability (final responsibility for the deliverable always rests with the root agent) and the flow of context stay simple
• Multi-vendor by design — it isn't confined to division of labor within the Claude family: a model name alone delegates to Codex (gpt-*), Devin CLI, or Cursor agent CLI. The requesting side isn't limited to Claude Code either

Children never communicate horizontally, and results always return to the parent through files. Who owns the final deliverable is structurally unambiguous at all times.

So which model should you actually delegate to?

That's the next question, naturally. To answer it, I run a benchmark called godot-llm-gamebench: the implementation of an original-spec puzzle in Godot 4.x + typed GDScript (not a known game, to avoid training-data contamination) is delegated from a parent agent (Claude Fable 5) to each vendor's models via delegate-implement, and auto-graded with a 100-point rubric built on hidden test code the delegatee never sees.

Each model runs 3 repetitions, with quality and efficiency (time, tokens, cost) measured on separate axes. The benchmark repository will be published later and covered in detail in a separate article; here is an excerpt of the latest adopted values from measurements taken 2026-07-05 through 07-10.

Model (harness)¹	Auto-graded score (max 300)²	Code quality (1–5)³	Total cost (median)	Wall clock (median)	Note
claude-sonnet-5 (Claude)	285.00	3.8	$2.27 (measured)	8.6 min	Top auto-graded score, incident-free. Two zero-warning runs
swe-1.7 (Devin)	273.00	4.1	$1.41 (bundled)	12.5 min	Big improvement over swe-1.6, with a 100-point run. But slowest tier
gpt-5.5 (Codex)	270.00	4.0	$3.48 (converted)	5.8 min	Perfect functional score in every rep, incident-free
cursor-grok-4.5 (Cursor)	264.00	3.3	$1.38 (converted)	4.8 min	Perfect functional score, fastest tier, fewest tokens
gpt-5.4-mini (Codex)	258.18	3.3	$2.04 (converted)	11.1 min	Fewest type warnings but slow, with a determinism drop and stalls
devin-deepseek-v4-pro (Devin)	258.00	3.4	$3.58 (estimated)	11.1 min	Perfect functional score in every rep, but slowest tier and pricey
composer-2.5 (Cursor)	257.36	3.8	$1.29 (converted)	6.5 min	Child cost of $0.04 is the lowest of all models
composer-2.5-fast (Cursor)	257.36	3.7	$1.76 (converted)	7.8 min	Wall clock swings widely with measurement timing
gpt-5.6-sol (Codex)	255.00	4.2	$3.10 (converted)	7.1 min	A stable 85 in every rep. Same quality as terra at twice the unit price
gpt-5.6-terra (Codex)	255.00	4.2	$2.38 (converted)	6.3 min	Matches sol at roughly half the cost and faster — the efficiency pick
claude-opus-4-8 (Claude)	255.00	3.5	$2.35 (measured)	8.4 min	Child aces functional tests every time (failures were parent/harness side)
devin-glm-5.2 (Devin)	253.18	3.8	$2.28 (estimated)	5.9 min	Fast and functionally accurate. Pre-completion stalls are the one flaw
cursor-gemini-3.1-pro (Cursor)	253.18	2.5	$2.13 (converted)	8.4 min	Warning-count swings and a stall habit. Highest token use among Cursor models
cursor-kimi-k2.7-code (Cursor)	253.18	4.5	$1.60 (converted)	10.6 min	Top-tier type discipline, but slowest of the Cursor models
gpt-5.3-codex-spark (Codex)	251.36	3.6	≥ $1.47 (child unknown)⁴	4.5 min	Fast but unstable on details
gpt-5.6-luna (Codex)	244.09	3.3	$1.95 (converted)	7.3 min	Cheap, but systematically misses spec details
swe-1.6 (Devin)	212.28	3.8	$0.95 (bundled)	3.9 min	Cheapest (bundled pricing) but lowest quality on both axes
claude-haiku-4-5 (Claude)	83.18 (n=1)	2.7 (n=1)	$2.53 (measured)	9.3 min	Completed 1/7. Frequent stalls, least reliable

Note: swe-1.7's child cost is $0 under bundled pricing during its free preview period (until 2026-08-08).

Baseline condition (does not go through the delegation protocol; reference only — not directly comparable with the table above):

Condition	Auto-graded score (max 300)²	Code quality (1–5)³	Total cost (median)	Wall clock (median)	Note
fable-direct (no delegation)	300.00	4.6	$2.62 (measured)	5.7 min	The parent (Fable) implements directly

¹ Each model's effort level is fixed to its single default. Bold marks models that passed the hidden tests (the 60-point axis) in all 3 repetitions.

² The sum over 3 repetitions (max 300) of a 100-point auto-graded rubric: hidden tests never shown to the delegatee (60), determinism (10), type quality (15), and project health (15).

³ A 5-point qualitative rating (average of 3 runs) of design aspects such as thoroughness of typing, Model/View separation, readability, and use of constants. Primary judge (sonnet) layered with a cross-check judge (gpt-5.6-sol); on divergence the operator (Fable) adjudicated the representative value.

⁴ The child process's token usage could not be measured, so the child cost is unknown; this is a lower bound of parent cost only (the actual total is higher). Shown as a triangle (▶) in the scatter plot.

There are plenty of caveats to reading these results (grading-method details, differing cost-accounting precision, sample size, confounding parent-side factors, and so on), but I'll leave those to the future article introducing the benchmark itself and skip them here.

Per-token price and per-task cost do not necessarily agree. Even with a cheap unit price, a model can end up costing more if it consumes more tokens or takes longer (inflating the parent-side cost). In this bench, devin-deepseek-v4-pro (input $1.74 / output $3.48) — priced at 1/3 to 1/9 of gpt-5.5 (input $5 / output $30) — consumed roughly twice the input tokens and ended up above gpt-5.5 in median total cost, $3.58 vs $3.48. Price sheets are only a starting point; what matters is the bill on real tasks.

Also, if you're on a vendor's subscription plan, your effective per-token cost is substantially lower than the published unit price, and the discount varies by company — but this article uses published token prices as a uniform yardstick.

Since this skill set puts token-cost efficiency first, let's compare the 16 models with an auto-graded score of 240 or higher on the two axes of cost and code quality.

Here's what the data suggests:

• Passing the functional tests in every rep is not exclusive to top-tier models — eight models passed the hidden tests (the 60-point axis) in all 3 repetitions: claude-sonnet-5 / swe-1.7 / gpt-5.5 / cursor-grok-4.5 / devin-deepseek-v4-pro / gpt-5.6-sol / gpt-5.6-terra / claude-opus-4-8. But only the fable-direct baseline reached a summed 300, and what spread the delegated models apart was the type-quality axis
• Even with equal functional-test results, code quality diverges — among those same all-pass models, gpt-5.6-sol / gpt-5.6-terra scored 4.2, gpt-5.5 4.0, and claude-sonnet-5 3.8, while claude-opus-4-8 stayed at 3.5, devin-deepseek-v4-pro at 3.4, and cursor-grok-4.5 at 3.3. That is the vertical spread in the chart. If you want code that is maintained, not just tests that pass, this axis is worth including in your choice
• The default is claude-sonnet-5; deviate only for a clear advantage — with the top delegated auto-graded score (285.00) and an incident-free record, claude-sonnet-5 is the delegation target most users will find easiest to use from Fable for implementation tasks. Choosing anything else requires some advantage. If code quality matters and you need something cheaper, swe-1.7 (based on Kimi K2.7) or cursor-kimi-k2.7-code are candidates; if speed matters and you need something cheaper, cursor-grok-4.5 and the like
• Delegation is not free — the fable-direct baseline (no delegation) took 5.7 min at $2.62 and was the only one of all 19 conditions with perfect scores in every run. Compared with the delegated runs on the same Claude harness (8.4–8.6 min, $2.27–$2.35), the cost difference on a single implementation task is small, and roughly 3 minutes of delegation overhead is added. If you only ever use Fable and the Claude family, you may not need delegate-skills much. Simply instructing the system prompt to proactively launch a specified model via the subagent tool for particular tasks may work well enough

To repeat: this is a small-scale measurement — a single task, 3 repetitions each. Please take it as nothing more than "an initial default for choosing a delegation target."

Finally, here's my own non-work configuration (.claude/settings.local.json) as an example:

{
  "env": {
    "DELEGATE_EXPLORE_MODEL": "composer-2.5",
    "DELEGATE_IMPLEMENT_MODEL": "composer-2.5",
    "DELEGATE_CHORE_MODEL": "composer-2.5",
    "DELEGATE_REVIEW_MODEL": "gpt-5.6-sol"
  }
}

I may publish a separate benchmark for delegate-review rather than delegate-implement. (Or I may not.)

Try it

Prerequisites

• Node.js and md2idx (installing beforehand isn't strictly required, but it's used for parent–child communication, so npm install -g md2idx is recommended)
• jq
• The CLI matching your delegation target (claude / codex / devin / Cursor's agent, each logged in)

Install

It installs via GitHub CLI (v2.90.0+) gh skill:

# Install individually (for Claude Code)
gh skill install oubakiou/delegate-skills delegate-explore --agent claude-code --scope project

# Or everything at once
for skill in delegate-explore delegate-implement delegate-chore delegate-review; do
  gh skill install oubakiou/delegate-skills "$skill" --agent claude-code --scope project
done

You can also install with the skills CLI from vercel-labs/skills:

npx skills add oubakiou/delegate-skills

Run

If you're fine with the default models, no extra configuration is needed. Just ask your main agent as usual, and delegation happens automatically based on each skill's description.

Find out where authentication is implemented in this repository

→ The main agent triggers delegate-explore, and a haiku child process does the investigating. The main agent reads the result file's index, then only the sections it needs.

You can also delegate explicitly by naming a skill:

Review the diff on this branch with delegate-review

And if you want it to delegate more aggressively, add a single line to your project's CLAUDE.md / AGENTS.md:

- To save tokens, actively delegate tasks to subagents using the delegate-\* skills

How it works under the hood

The main agent and the child talk through a file-based request/response protocol. Both files are written in md2idx format (index + sections), so they can be read progressively, saving tokens.

Each skill's execution flow:

1. prepare.sh — prerequisite checks → model resolution (DELEGATE_<TYPE>_MODEL env → skill default) → recursion guard against multi-hop delegation → request generation
2. dispatch.sh — deterministically selects the backend from the model-name prefix and launches the child process via a shell wrapper
3. read-response.sh auto — reads the response (progressively if large) → validation

Fail-safe design

Guardrails are built in so that "fire and forget to a cheap model" doesn't end in accidents:

• Recursion guard — if the same kind of delegation occurs twice in a multi-hop chain, it stops with exit 4
• Fail-closed — if a prerequisite (like md2idx) is missing, it fails instead of silently continuing
• Restricted tool permissions — delegatees can't push; explore / review are read-only

Files generated per delegation

Each delegation (run) generates the following under DELEGATE_WORK_DIR (when unset, TMPDIR per mktemp's defaults, else /tmp):

• request file — what the parent asks of the child. Alongside the md2idx-format JSON the agent reads (*_req.json), a same-content markdown (*_req.md) is generated for human debugging
• response file — the child's report of its results. Also a pair: agent-facing JSON (*_res.json) and human-debugging markdown (*_res.md)
• observe JSON — an observation record of execution state, heartbeats, token usage, and more
• per-run scratch directory — temporary work area for the child process

Since the default /tmp location can be wiped across days, if you want to investigate failures or monitor externally, pinning it to an ignored directory inside your repo — e.g. DELEGATE_WORK_DIR=.temp/delegate/work — is recommended.

Resumable sessions for review-fix loops

Normal delegations are throwaway, but for larger delegate-implement / delegate-chore work where a review → fix loop is expected, the main agent can explicitly start a resumable initial run. The observe JSON records a resume handle and lineage, and subsequent follow-ups resume the same backend session. This is fail-closed too: if validation fails, it does not silently fall back to a new session.

Delegation-cost observability

The child process's token usage is recorded in the observe JSON. All four backends — Claude / Codex / Devin / Cursor — can report measured values (measured); when unavailable, it falls back to a chars/4 estimate (estimated), and the two are clearly distinguished. For backends that report measured tokens but no cost (like Codex), a cost_usd_estimated converted from a bundled price table is attached. In other words, you can verify after the fact whether delegating actually made things cheaper.

Who it's for

You use Claude Code / Codex / Devin / Cursor as your main agent, and:

• your token bill is on your mind
• in long sessions, your main agent's context fills up with investigation logs and you can feel the quality of its judgment degrade
• you have CLIs from multiple vendors and want to use the right model for the right task

Wrap-up

At the core of delegate-skills is a simple division of labor: "the expensive model's job is judgment and responsibility; the cheap model's job is reading and writing." It realizes this with nothing but the skill mechanism — no dedicated infrastructure — spanning four backends with a single model name, with reliability underwritten by a file-based protocol and fail-safe design.

Installation is one gh skill install. Start with delegate-explore, and experience investigation tasks getting done at Haiku prices.

Repository: https://github.com/oubakiou/delegate-skills
License: MIT