Subagents vs agent skills — subagents helped only when skills had input-output contracts

1. Executive summary

An agent skill is a reusable knowledge package: instructions (SKILL.md) bundled in one folder with scripts and reference documents. A subagent is a separate context window that the main agent opens to hand off a subtask. The paper treats these not as two separate features but as two ways to execute the same skill package, and compares them. [1]

The accuracy figures in this article are approximate values we read from the paper's figures. The paper gives no accuracy tables; the only printed numbers are in the peak-context-ratio figure. Treat the readings as accurate to about ±0.02. Each section states which values are printed and which we read.

2. How the two execution modes differ

Anthropic's skills documentation says a skill enters the context in three stages. The name and description are always in the system prompt (about 100 tokens per skill); once the skill is selected, the SKILL.md body is loaded (recommended to stay under 5,000 tokens); and reference files enter only when they are read. [5] In this mode, the main agent itself carries out the skill's procedure. After it reads the instructions, every step it takes to follow them accumulates in the main context.

This is where the paper sees a problem. In reinforcement learning, a "skill" is a policy that, once a higher-level controller invokes it, runs several steps on its own and then terminates. Agent skills use the same word, but in practice invoking one only adds instructions to the context. Even when the instructions are useful, a longer context lowers the model's reasoning quality, so the longer the task, the more invoking a skill becomes a burden in itself. [1] We covered performance loss with context length separately in our report on context degradation.

The paper rests on two hypotheses. First, splitting a task across several context windows reduces the maximum length any single window has to process, and what drives performance is this peak length, not total tokens. As support, the paper cites earlier work showing a limit on how much information a model can carry across a long input. [6] Second, because a subagent cannot see the main context, the main agent must be able to decide, from the skill description alone, which subagent to call and what to pass it. This second condition is what drives the paper's conclusion.

3. What was measured, and how

The testbed is SkillsBench, a benchmark built to measure how much agent skills help. It has 87 long-horizon tasks across 8 domains, and each task comes with human-written skill packages and a verifier that grades results by the same criteria every time. The SkillsBench paper reported that these skills raised the average pass rate across 18 combinations of model and execution environment (harness) from 33.9% to 50.5%. [2]

The subagent paper uses only 64 of those 87 tasks. When the authors reviewed the existing skills, they found almost none stated their inputs and outputs, so they built a separate skill set. The procedure: run an OpenHands agent with GPT-5.3 Codex three times on every task, collect the successful trajectories, and hand them to GitHub Copilot CLI to synthesize 3–5 procedural skills per task. The experiments cover the 64 tasks for which synthesis succeeded. The paper calls this set the synthesized set and the existing skills the curated set. [1]

The synthesized skills' descriptions follow a fixed format: a one-line summary followed by Expected input and Output items. To take one example from the paper's appendix, a skill that turns a vulnerability scanner's JSON report into normalized records takes as input "the scanner JSON report path from the scan step" and "the required severity filter and CSV columns from the audit plan," and returns as output "a JSON list of normalized records with Package, Version, CVE_ID, Severity, CVSS_Score, Fixed_Version, Title, and Url fields." [1] This format is what the paper means by an input-output contract.

4. Result 1: only with input-output contracts

Here is what the paper's text says. On the curated set, "agent skills match or outperform subagents across all models." On the synthesized set, "subagents outperform agent skills, with the gain being largest for smaller models that are more bandwidth limited," that is, models with a more limited ability to handle the information they need from a long input all at once. [1] Below is the average task accuracy we read from Figure 2.

Approximate values read from Figure 2 (±0.02); the paper does not print these numbers. The condition is a flat library that exposes every synthesized skill at once (see Section 5).

Setting the table next to the paper's text shows two things.

• On the synthesized set, the large gaps are on the small models. Switching to subagent execution more than doubled accuracy for Gemma-4-12B and Qwen3.5-9B, and nearly doubled it for Mistral-Large-3.1. The top two models, by contrast, scored almost the same either way: gpt-5.3-codex tied, and Kimi-K2.6 was actually slightly higher with agent skills. This matches the paper's statement that the gain is "largest for smaller models."
• The paper's statement about the curated set differs slightly from its figure. The text says agent skills "match or outperform subagents across all models," but in the figure the subagent reads 0.02–0.04 higher on the four small models. That difference overlaps with our reading error, so it does not amount to a refutation. What the figure does show clearly is gpt-5.3-codex, where the subagent fell well behind: 0.71 for the skill versus 0.61 for the subagent. In other words, running skills without contracts as subagents cost the most on the strongest model.

The paper's interpretation: when a skill is designed as a unit of work with a procedure and a clear input and output format, subagent execution has the advantage; when it holds only loosely structured knowledge, putting it directly into the main context works better. This interpretation points back to the second condition in Section 2. Without a contract, the main agent does not know what to pass, and the subagent has to finish the job with only what it received. [1]

5. Result 2: as the context grows

The second experiment raises context pressure artificially. It adds the descriptions of distractor skills, which are not needed to solve the task, to the system prompt (0, 100, 200 and up to 263 of them) and measures accuracy again. The setup mimics real environments with many tools available. The paper's conclusion is that "subagent execution degrades more gracefully." [1] The values below are read from Figure 3 in the main text.

Approximate values read from Figure 3 (±0.02). Synthesized set. The main-text figure shows only three models; the other four are in an appendix figure, and the paper says the interpretation is the same.

The key column is 0 distractors. With no distractor skills, gpt-5.4-mini scores 0.82 in both modes. The gap appeared as distractors were added. So on this model, subagents do better not because the skill runs in a fresh context as such, but because they avoid piling more instructions onto a context that is already large. The paper says the same: "keeping skill instructions out of an already-large context matters even more as that context grows." [1]

This table is also the key to reading the one in Section 4. The values in the 263-distractor column (Qwen3.5-9B 0.22 and 0.46, gpt-5.4-mini 0.56 and 0.71) match the synthesized-set values in the Section 4 table. The paper's appendix says the baseline for Section 4 is a flat library in which "all leaf skills are exposed to the agent simultaneously" (leaf skills are the executable skills at the bottom of the hierarchy), so the Section 4 gaps should be read as measured with every synthesized skill exposed. This is our inference from comparing the two figures; the paper does not state it in words. For an environment with only a few skills, the paper gives no grounds to expect gaps as large as those in Section 4.

6. Result 3: total tokens rose; peak context fell only on strong models

The trade-off the paper predicts is that subagent execution "trades a higher total token count for reduced peak context length." Here, peak context length is the longest context any single window processed at one time while solving one task. When several subagents are opened, the largest of their peaks is used. This is the only metric for which the figure prints its numbers. [1]

The shares are the values printed on the left of Figure 4. Token counts are approximate readings from the right of Figure 4, rounded to the nearest 10,000. Synthesized set. The "~1.7×" in the executive summary is our derived value, from dividing the two gpt-5.3-codex values.

Total tokens were higher with subagents on every model: 1.3–1.7× the agent-skill figure, by our readings of the figure. The paper states the reason plainly. A skill keeps the information in a single context, but with a subagent, information the main agent already holds has to be passed on again, which creates duplication. [1] In its conclusion the paper suggests designing contracts to be minimal to cut this cost, but leaves how to minimize them as an open problem.

The share of tasks where the subagent's peak context was shorter varied widely by model. On gpt-5.3-codex the subagent's was shorter on 95.3% of tasks, but on Ministral-8B the share was only 28.1%, so more tasks had a shorter peak context under agent-skill execution. The paper's explanation: under agent-skill execution, a small model's reasoning breaks down and it ends the task early, so its context stays short; under subagent execution, each subagent spends the tokens its subtask needs all the way to the end, so the context ends up longer. The paper therefore limits the peak-context comparison itself: it is "only comparable across models whose success rates are similar under both execution modes," and only the stronger models meet that condition. [1]

The same pattern shows up in the number of skill calls. According to an appendix figure, subagent execution led to more skill calls per task on every model. gpt-5.4-mini called a skill only about 0.7 times per task with agent-skill execution, versus about 2.5 times with subagent execution (read from the figure). The paper's interpretation is that as the context grows, the model no longer goes through enough reasoning steps, so it calls skills less often. [1] If you share the common complaint that the model does not use the skills you have installed, this figure offers one explanation.

7. Run everything as subagents and accuracy collapses

The appendix has one result that bears on practice more directly than anything in the main text. It tests, on a single model (Qwen3.5-9B), whether organizing a large skill library into a hierarchy helps. Skills are grouped into a tree or a graph with routing nodes: selecting a higher-level node reveals the list of nodes under it. Execution was then split three ways: every node run as an agent skill; every node run as a subagent; and a hybrid in which routing nodes stay agent skills and only leaf skills run as subagents. [1]

Approximate values read from the appendix figure (±0.02). Qwen3.5-9B only. The flat structure has no routing nodes, so "fully subagent" and "hybrid" are the same setting there.

Once there is a hierarchy, the setting that also ran the routing nodes as subagents fell to 0.03–0.07 accuracy. That loses almost all of the flat structure's 0.46. The hybrid mode, by contrast, was best in every structure, and on the two-level task tree it reached 0.64, above the flat structure's 0.46. The paper explains this with the same logic as its main hypothesis: routing nodes only make a selection and carry neither a procedure nor an input-output contract, so they should run in the main context, and only leaf skills, which have contracts, are worth isolating. [1]

This experiment used only one model, and the paper itself leaves "a systematic study of deeper hierarchies and tree-vs-graph structure to future work." The direction is still clear. If you generalize Section 4's finding that subagents did better into "run every skill as a subagent," accuracy can collapse.

8. Claude Code offers the same choice

In Claude Code, frontmatter options (the settings block at the top of the file) let you choose between the paper's two execution modes. This is based on the official documentation as checked on 2026-09-11. [3] [4]

A warning in the docs says the same thing as the paper's conclusion: "context: fork only makes sense for skills with explicit instructions. If your skill contains guidelines like 'use these API conventions' without a task, the subagent receives the guidelines but no actionable prompt, and returns without meaningful output." [3] That is exactly the situation the paper saw with the curated set. The docs describe behavior, though, while the paper measured accuracy, so the two point the same way on different kinds of evidence.

The subagents docs also describe the cost. They say a regular subagent, one not using context: fork, "starts fresh and may need time to gather context," and advise using the main conversation when latency matters. [4] Anthropic's post on using subagents says the same: "Each one spins up its own context, consumes tokens, and adds a layer of indirection between the developer and the work." [7] This points the same way as the increase in total tokens the paper measured.

A recent debate among developers sits at exactly this point. On September 8, 2026, a skill that forces concise answers got more than 500 points on Hacker News, and commenters repeatedly reported that the skill's effect wears off after a few turns. [8] These are community anecdotes, not measurements. The complaint that a norm-type skill gets diluted in the main context connects to the context buildup the paper identifies as the problem, but the paper did not measure how conversational norm skills lose their effect. And if the paper's results hold, norm-type skills like this are not the kind of problem you solve by moving them into a subagent. An output-format norm has to apply to the main agent's own responses, so it cannot be isolated.

9. Checklist to apply today

• Split your skills into two kinds: procedural skills, for which you can write down "what it takes and what it produces," and norm-type skills that hold conventions, terminology and cautions. The paper's results apply only to the first kind.
• Write inputs and outputs into each procedural skill's description. Follow the paper's appendix format with Expected input and Output items, and describe the output so the main agent can use it as-is in its next step, for example "a file at this path" or "a result with these fields." The description is the part that is always in context, so watch its length too. [5]
• Try switching one procedural skill to context: fork. The subagent cannot see the conversation history, so first check that the skill body can run to completion from its inputs alone. If the body refers back to the conversation, as in "as discussed above," it cannot be forked.
• Measure three things together: task success, total tokens per task, and the peak context length of the main conversation. Based on the paper, expect total tokens to rise to 1.3–1.7×, and check whether that cost is recovered in success rate or in how long the main conversation lasts.
• Do not fork skills whose job is to choose other skills. Keep router-style skills that guide the agent through a list of skills, and skills that decide which procedure to use, in the main context. This is where the Section 7 result applies.
• The stronger the model, the lower your expectations. In the paper, the top model had the same accuracy in both modes. In that case the purpose of forking is preserving the main context, not accuracy, and the cost is only worth paying in long sessions that need it.
• With only a few skills, there is no rush. In the 0-distractor column in Section 5, gpt-5.4-mini scored the same in both modes. The gap appeared as the number of exposed skills and tools grew.

10. What this is not yet

• This is a preprint that has not been peer-reviewed. It is the first version, posted to arXiv on September 7, 2026, in the NeurIPS 2026 template. Whether it has been accepted could not be confirmed.
• The accuracy figures are our readings from the figures. The paper provides no accuracy tables. The only printed numbers are the seven peak-context ratios in Section 6. Read the other values as carrying a reading error of about ±0.02; any interpretation of a 0.02–0.04 difference falls within that error.
• The experiments cover 64 of the 87 tasks. Only tasks for which synthesized skills could be built remained, and the criterion was whether GPT-5.3 Codex had a successful run among its three attempts. Harder tasks may have been left out.
• The synthesized skills were built from successful runs of the same tasks. Skills that people write in advance in real projects do not come from the correct solution to the task at hand. Whether ordinary skills with contracts deliver the same gain is not something this paper measured.
• The harness is a modified OpenHands. The authors replaced the system prompt with one telling the agent to "always use tools," implemented subagents as MCP tools, and raised the tool timeout to 2 hours. Whether Claude Code's context: fork produces the same gap has to be measured separately. The mapping table in Section 8 only shows how the concepts correspond; it does not mean the paper's measurements can be carried over to Claude Code as they are.
• That Section 4's baseline is "all skills exposed" is our inference. We drew it from the match between the 263 column in Section 5's table and the values in Section 4's table, and from the appendix naming the flat library as the baseline. The paper does not state it in words.
• The paper itself limits the peak-context comparison to the strong models. The low shares on small models may reflect agent-skill runs ending early, rather than subagents failing to reduce context.
• The hierarchical-library experiment used one model, Qwen3.5-9B. Whether the "fully subagent" collapse is as large on other models has not been verified.
• There are small inconsistencies between the text and the figures: "over 80%" in the text against a printed 79.7%, and the statement that agent skills "match or outperform subagents across all models" against a figure that reads slightly the other way on the small models. Neither is large enough to change the conclusions.
• Latency was not measured. The paper covers only tokens and context length. The time cost of calling subagents in sequence appears only as a caution in the Claude Code docs.

11. Sources

All checked on 2026-09-11. For [1], we downloaded the arXiv LaTeX source and checked the body, appendix and figure files directly. Product documentation is the vendor's description of behavior, not an independent experiment. [8] is a community discussion and a secondary source.

Editorial standard: every value the paper does not give in a table is marked each time as an approximate reading from a figure, and where the text and a figure disagree, we gave priority to the printed value. Where the product docs and the paper point the same way, we still noted that the evidence is of a different kind.