Subagents vs Agent Skills: Executing Reusable Knowledge for Long-Horizon Agentic Tasks
Wasu Top Piriyakulkij, Rachel Lawrence, Alicia Curth, Sushrut Karmalkar, Niranjani Prasad
cs.AI · cs.CL · cs.LG
Quick verdict
Shows subagents beat in-context skill loading only for contract-driven procedural packages; solid multi-model study, but mode and skill content are confounded.
Summary
This paper asks whether LLM agents should execute reusable skill packages by loading their instructions into the main agent's context (agent skills) or by spawning fresh subagent contexts per subtask. Formalizing both modes over identical packages (Section 2), the authors invoke the reinforcement-learning options framework to argue that subagent execution wins when packages are procedural with explicit input-output contracts, trading reduced peak context for higher total token cost. On SkillsBench (64 of 87 tasks, OpenHands harness, seven models from Ministral-8B to GPT-5.3-Codex), curated SkillsBench packages favor agent skills, whereas newly synthesized contract-driven packages — distilled from successful GPT-5.3-Codex trajectories via Copilot CLI — reverse the ranking, with the largest gains for smaller models (Figure 2). With up to 263 distracting skills, subagents degrade more gracefully (Figure 3); for strong models they cut peak context on 70-95% of tasks (GPT-5.3-Codex: 95.3%) but consume substantially more tokens (Figure 4), while weak-model comparisons are confounded by early termination. Appendix A.1 finds hybrid library organization (routing nodes inline, leaf skills as subagents) best. Main limitations: execution mode is confounded with package content, no confidence intervals or significance tests are reported, synthesis depends on proprietary frontier models with train-on-test leakage, and no code release is stated.
Review complete
Assessment at a glance
4
risk flags identified
● high 1
● medium 2
● low 1
5 strengths · 4 weaknesses · 5 author questions
AI text signal = Binoculars zero-shot detector score over 20 sampled passages (Fast-DetectGPT co-reported) — absence does not prove human authorship, and a flag does not imply misconduct.
Levels reflect verification complexity — not a quality score. Evolve never rates your paper.
Key claims under review
- Subagent execution outperforms agent-skill execution when skill packages are procedural and expose explicit input-output contracts, with the largest gains for smaller models.
- Subagents trade higher total token cost for reduced peak context length and degrade more gracefully as initial context grows with up to 263 distracting skills.
- Contract-driven procedural skill packages can be synthesized from successful trajectories and outperform curated SkillsBench packages under both execution modes.
- Hybrid skill-library organization — routing nodes executed inline as agent skills, leaf skills as subagents — yields the best accuracy among tested layouts.
Strengths
Clean formalization isolating execution mode
Section 2 (Eqs. 4-7) defines agent-skill and subagent execution over the identical package s=(d,m,R), making execution mode the only manipulated variable within each column of Figure 2; the options-framework mapping (Eqs. 8-10) gives the contract design a principled pedigree.
Broad model coverage under a fixed harness
Seven models spanning Ministral-8B to GPT-5.3-Codex run in OpenHands with a deliberately minimal system prompt (Figure 8), a fixed subagent template (Figure 9), and native skill retrieval disabled (Appendix A.3), plus a no-skill baseline in Figure 2.
Honest handling of the peak-context confound
Mechanism-targeted stress tests
Practical synthesis pathway
Weaknesses
Mode is confounded with package content
No uncertainty quantification
Train-on-test synthesis via proprietary tools
Single benchmark and single-model appendix
Full Review Report
$1.99 · one-timeUnlock the complete preliminary analysis Evolve produced for this paper.
Report preview
Scope & Claims
The paper addresses one design question for tool-calling LLM agents: for a fixed skill package s = (d, m, R) (Section 2, Eq. 4), should its instructions be loaded into the main agent's context (agent-skill execution, Eq. 5) or should a fresh context be spawned conditioned on those instructions, returning only the final message (subagent execution, Eqs. 6-7)? Section 3 develops two claims: (i) subagents reduce peak context length at the price of duplicated input tokens (Section 3.1); (ii) this pays off only when packages are procedural and expose explicit input-output contracts d = (q_in, h, q_out), mapped onto the options framework (I, pi, beta) (Section 3.2, Eqs. 8-10). Both claims are stated conditionally in the abstract, which is appropriate hedging.
The remaining sections cover Methodology Assessment, Statistical Evidence, Results & Reproducibility, Limitations & Risks, and Verdict & Recommendations.
- All 5 strengths & 4 weaknesses, analyzed in detail
- 4 risk flags with severity, section & reviewer questions
- Methods & statistical evidence assessment
- 5 questions a peer reviewer would ask
- Full six-dimension evaluation report & recommendations
One-time purchase · this paper only
One-time purchase, this paper only. AI-generated preliminary analysis — not peer review.
Frequently asked questions
What is the difference between an agent skill and a subagent?
In this paper, an agent skill loads a skill package's SKILL.md instructions into the main agent's context, and the main agent follows them itself. A subagent instead spawns a fresh context window seeded with the same instructions, solves the subtask independently, and returns only its final output to the main agent, keeping intermediate reasoning hidden.
When do subagents outperform agent skills?
The authors find subagents win when skill packages are procedural and specify explicit input-output contracts — as with their synthesized packages on SkillsBench — especially for smaller models. Loosely structured, human-curated packages without contracts still favor in-context (agent-skill) execution.
What does subagent execution cost compared to agent skills?
More total tokens: information must be repeated into each subagent's fresh context. In exchange, the peak context length per window drops — on 70-95% of tasks for the strongest models tested (95.3% for GPT-5.3-Codex) — and accuracy degrades more gracefully as the number of distracting tools grows up to 263.
Is code or the synthesized skill package set available for this paper?
The paper text contains no code or data release statement. Synthesis relied on Copilot CLI powered by proprietary models (Claude Opus 5, with GPT-5.5 subagents) applied to successful GPT-5.3-Codex trajectories on the benchmark itself, so re-deriving the exact packages would be difficult without a release.
About this review
This is an AI-generated preliminary review by Evolve.Pub, produced from the openly available text of the paper. It is not peer review and does not represent the authors' views. The canonical record of the paper is at the publisher link above.
- Exact per-model accuracy values in Figures 2, 3 and 5 exist only as plot graphics; the extraction contains axis labels and the Figure 4 percentages (28.1%-95.3%) but not the underlying accuracy numbers, so effect sizes could not be independently quantified.
- The provided text runs cleanly from the abstract through Appendix A.5 and reference [37] with no mid-sentence cutoff; all quoted numbers were verified present in the extracted text.
Go deeper on this paper
Wrote a paper? Stress-test it before reviewers do.
Upload your manuscript for the same structured scrutiny — reasoning, statistics, evidence, figures, and reproducibility.