Subagents vs Agent Skills: Executing Reusable Knowledge for Long-Horizon Agentic Tasks | AI Paper Digest

TL;DR Highlight

Running skills as subagents beat agent-skill loading when skills had clear input-output contracts

Who Should Read

Agent developers whose long-running agents degrade after loading SKILL.md files into the main context

Core Mechanics

Loading skills into context can backfire
- An agent skill loads SKILL.md straight into the main context.
- Agent performance drops as context grows, and skills add to that load.
Subagents run skills in a fresh context
- A new context seeded with the skill instructions solves the subtask and returns only the final result.
- The main agent has less to reason over, so it reasons better.
Subagents win only with I/O contracts
- With the human-authored SkillsBench skills (no I/O contracts), agent skills matched or beat subagents.
- With procedural skills plus I/O contracts, subagents came out ahead.
Smaller models gain the most
- With contract-based skills, the subagent gain was largest for smaller models that are more bandwidth limited.
The price is more tokens
- Each subagent must be handed information the main agent already holds, so total tokens rise substantially.

Evidence

Tasks with lower peak context
- Subagents had lower peak context than agent skills on 95.3% of tasks for gpt-5.3-codex and 79.7% for Kimi-K2.6.
- Weaker models showed smaller or reversed reductions, e.g., Ministral-8B 28.1% and Mistral-Large-3.1 32.8%.
Degrades more gracefully with distractors
- On SkillsBench, with 0 to 263 distracting skills added, subagent accuracy fell more gently.
- Exact values are only in the figure, not in the text.
Experiment scale
- Evaluation used the 64 of 87 SkillsBench tasks for which synthesized skill packages were built.
- Skills were synthesized from successful GPT-5.3 Codex trajectories over three runs.
Skill call counts
- Subagent execution led to more skill calls per task across all base LLMs.
- The authors attribute this to LLMs underthinking as context grows under agent-skill execution.

How to Apply

Write Expected input and Output in skill descriptions
- Spell out the required inputs and the returned output in the description of any skill you'll run as a subagent.
- Check that SKILL.md is truly a procedure that turns that input into that output.
Split only procedural skills into subagents
- Run skills with clear inputs and outputs as subagents in separate contexts.
- Keep loosely structured reference-knowledge skills loaded into the main context as before.
Mine skills from successful runs
- Collect logs of successful agent runs and have a coding agent turn them into skill packages with I/O contracts.
- Fix any missing contract fields by hand.
Group many skills into a hierarchy
- Don't expose all skills at once; show top-level routing nodes first and reveal children step by step.
- Run routing nodes inline and leaf skills as subagents.

Try It

copy & run

# Paste into Claude Code or ChatGPT (simplified version of the paper's method: adding I/O contracts to skill descriptions)

Below is an agent skill SKILL.md I use. Rewrite it so it can be run as a subagent.

[SKILL.md]
{{SKILL.md contents}}

Requirements:
1. Rewrite the description as 'one-line summary / Expected input: (bullets) / Output: (bullets)'.
2. Organize the body as procedure steps that turn the input into the output.
3. Do not assume knowledge of the main conversation; put everything needed into Expected input.
4. Add a final step: 'Report the output result or file path in the final message.'

Next, try this: first ask it to judge whether this skill is a procedural skill with I/O contracts or a reference-knowledge skill.

Terminology

Agent SkillA package of instruction files like SKILL.md plus scripts. When invoked, the instructions are loaded into the main context and the agent follows them.

SubagentAn agent that solves a subtask in a fresh context seeded with skill instructions and returns only the final response. Like outsourcing a job and getting back just the deliverable.

Peak context lengthThe longest length any single context window had to process during a task. Think of it as the heaviest load carried at once, not total tokens.

Input-Output ContractA natural-language promise stating what input a skill takes and what output it returns. Similar to a function signature.

SkillsBenchA benchmark for measuring agent-skill effectiveness, made up of 87 long-horizon agentic tasks across diverse domains.

Related Papers

Original Abstract (Expand)

How can language model agents effectively leverage libraries of reusable knowledge to solve long-horizon tasks? Recent work has increasingly focused on agent skills: reusable capabilities represented as skill packages, i.e., multi-file bundles containing instructions, scripts, and other resources that help agents perform specific tasks. Agent skills are typically executed by loading their skill instructions into an agent's context and relying on the agent to follow them. As task horizons grow, however, this approach becomes increasingly brittle, because reasoning quality degrades as more information accumulates in the context window. We investigate an alternative approach in which skill packages are instead invoked as subagents. Rather than loading skill instructions into the main context, subagent execution spawns fresh context windows dedicated to solving individual subtasks. We show that subagent execution outperforms agent-skill execution when skill packages expose clear input-output contracts and their instructions encode the procedural knowledge needed to fulfill those contracts. The tradeoff is additional communication overhead, as extra tokens are required to coordinate between the main agent and its subagents. Our results show that the benefit of reusable knowledge depends not only on its content, but also on how it is organized and invoked.