Subagents vs Agent Skills: Executing Reusable Knowledge for Long-Horizon Agentic Tasks

# Subagents vs Agent Skills: Executing Reusable Knowledge for Long-Horizon Agentic Tasks
Source: [https://arxiv.org/html/2609.09233](https://arxiv.org/html/2609.09233)
Rachel LawrenceAlicia CurthSushrut KarmalkarNiranjani PrasadCornell UniversityMicrosoft Research Cambridge

###### Abstract

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\.

11footnotetext:Work done during an internship at Microsoft Research Cambridge\.## 1Introduction

How do we equip AI agents with domain\-specific knowledge so that they can solve complex tasks? This is a longstanding question in AI, dating back to the symbolic AI era, where researchers attempted to encode knowledge explicitly through structured representations such as rules, logic, and knowledge graphs[Shortliffe \(1976\)](https://arxiv.org/html/2609.09233#bib.bib31);[Lenat \(1995\)](https://arxiv.org/html/2609.09233#bib.bib32);[Brachman et al\. \(2004\)](https://arxiv.org/html/2609.09233#bib.bib33);[Speer et al\. \(2017\)](https://arxiv.org/html/2609.09233#bib.bib34)\. The rise of deep learning shifted the paradigm from direct knowledge injection to weight\-based learning; knowledge is acquired from data and stored implicitly in neural weights\. The advent of large language models \(LLMs\) has partially shifted the field back toward explicit knowledge injection\. Through in\-context learning, LLMs acquire and apply new information at inference time, without weight updates, in one of the most expressive symbolic representations: natural language\.

Recently,*agent skills*[Anthropic \(2025\)](https://arxiv.org/html/2609.09233#bib.bib4)have emerged as an effective way of knowledge injection for LLM agents\. Each agent skill is represented by a*skill package*: a multi\-file package containing instructions and scripts that are useful for solving specific tasks\. The names and descriptions of available skills are then given to the LLM agent\. When the agent invokes a skill, it gains access to that skill’s instructions and follows them\. These agent skills have become the dominant way of providing LLM agents with reusable, domain\-specific knowledge\.

Despite their name, agent skills are quite different from the notion of a skill in reinforcement learning[Sutton et al\. \(1999\)](https://arxiv.org/html/2609.09233#bib.bib1);[Parr and Russell \(1997\)](https://arxiv.org/html/2609.09233#bib.bib35);[Dietterich \(2000\)](https://arxiv.org/html/2609.09233#bib.bib3): a skill is a temporally extended policy invoked by a higher\-level controller\. Invoking agent skills, instead, simply loads the skill recipes \(SKILL\.md files\) into the LLM agent’s context, rather than directly performing the skill or solving a subtask\. Thus, even when an agent skill contains relevant information, invoking it might be unproductive, as adding more instructions increases context length, and agent performance degrades as context grows[Liu et al\. \(2024\)](https://arxiv.org/html/2609.09233#bib.bib7);[Du et al\. \(2025\)](https://arxiv.org/html/2609.09233#bib.bib8);[Hong et al\. \(2025\)](https://arxiv.org/html/2609.09233#bib.bib6);[Li et al\. \(2026a\)](https://arxiv.org/html/2609.09233#bib.bib5)\. This issue of bloated context becomes increasingly problematic as task horizons become longer\.

We therefore investigate an alternative approach to agent skills: executing skill packages assubagents\. Instead of loading skill instructions into the main context, subagent execution spawns a new context window seeded with the skill instructions, performs the skill independently, and returns only the output to the main agent\. We possess that by dividing a task across multiple context windows, the maximum amount of information processed by any individual context can be reduced \([Figure1](https://arxiv.org/html/2609.09233#S1.F1)\)\. While existing agent harnesses do have subagents, they are generally underutilized, targeting mainly situations where independent subtasks can be run in parallel to reduce latency[Anthropic \(2026\)](https://arxiv.org/html/2609.09233#bib.bib36)\. Executing skills as subagents has downsides, however\. For instance, we lose the ability to combine knowledge from multiple skills to solve a subtask\.

In this work, we show that a skill package is suitable for subagent execution when it is presented as procedural knowledge with clear input and output contracts, analogous to the options framework in reinforcement learning[Sutton et al\. \(1999\)](https://arxiv.org/html/2609.09233#bib.bib1)\. Procedural skills with well\-defined input\-output interfaces are inherently self\-contained, allowing their internal reasoning to be delegated to separate contexts\. On SkillsBench, a benchmark for evaluating agent skills, we synthesize procedural, contract\-driven skill packages derived from successful task trajectories and show that executing these skill packages as subagents significantly outperforms agent\-skill execution\. Our findings suggest that both how skills are executed and how skill knowledge is organized are important design choices that substantially impact agent performance\.

Figure 1:Two type of skill package execution: agent skill vs subagent\. While agent\-skill execution does all the reasoning in a single context, subagent execution creates new context windows for each subtasks, each window initialized with skill instructions \(SKILL\.md\)\. Since subagents reason within their own context, however, extra tokens are needed for the main agent and subagents to communicate\.
## 2Background: Agents with Tools, Agent Skills, and Subagents

We are interested in a tool\-calling language model agent that operates iteratively\. Letctc\_\{t\}denote the agent’s context at turntt\. For notational simplicity, we assume the agent invokes one tool per turn\. At each turntt, the language modelπL​L​M\\pi\_\{LLM\}generates a text responsertr\_\{t\}, a toolktk\_\{t\}, and tool argumentsxtx\_\{t\}:

\(rt,kt,xt\)=πL​L​M​\(ct\)\(r\_\{t\},k\_\{t\},x\_\{t\}\)=\\pi\_\{LLM\}\(c\_\{t\}\)\(1\)The selected tool is executed by a tool executorEE:

ot=E⁡\(kt,xt\)o\_\{t\}=E\(k\_\{t\},x\_\{t\}\)\(2\)whereoto\_\{t\}denotes the tool output\. The agent context is then updated by appending the response, tool call, and tool result:

ct\+1=ct⊕\(rt,kt,xt,ot\)c\_\{t\+1\}=c\_\{t\}\\oplus\(r\_\{t\},k\_\{t\},x\_\{t\},o\_\{t\}\)\(3\)We slightly abuse notation and use⊕\\oplusto denote appending an interaction trace to the context\. Any structured objects are assumed to be converted into their textual representations before concatenation\. The agent repeats this process until a final answer is produced at some turnTT\.

#### Agent Skills\.

An agent skill is specified by a skill packagess:

where the descriptionddprovides a concise summary of the skill’s purpose and is always given to the main agent for skill discovery, the instruction filemm\(implemented asSKILL\.md\) specifies how the skill can be performed, and the resource collectionRRcontains supporting artifacts such as scripts, examples, reference documents, and nested directories\.

An agent skill is a tool constructed from a skill package,k=AgentSkill⁡\(s\)k=\\mathrm\{AgentSkill\}\(s\), and we writemkm\_\{k\}for the instruction file of its underlying package\. Invoking an agent skill requires no additional arguments and simply returns the skill instructionsmkm\_\{k\}:

E⁡\(k=AgentSkill⁡\(s\),∅\)=mk\.E\(k=\\mathrm\{AgentSkill\}\(s\),\\varnothing\)=m\_\{k\}\.\(5\)The skill contents are thus exposed directly to the main context, and the procedure prescribed bymkm\_\{k\}is carried out byπL​L​M\\pi\_\{LLM\}itself: each step of the skill’s execution is an ordinary agent step in the main contextcc, applying[Equations1](https://arxiv.org/html/2609.09233#S2.E1),[2](https://arxiv.org/html/2609.09233#S2.E2)and[3](https://arxiv.org/html/2609.09233#S2.E3)

#### Subagents\.

Subagents provide an alternative mechanism for utilizing reusable knowledge\. Like agent skills, a subagent is constructed from a skill package,k=Subagent⁡\(s\)k=\\mathrm\{Subagent\}\(s\)\. Unlike agent skills, however, invoking a subagent does not expose the skill instruction file directly to the main agent, nor is its execution carried out byπL​L​M\\pi\_\{LLM\}\. Instead, the tool executor instantiates a distinct policy that conditions on the skill instructionsmkm\_\{k\}and initializes a new agent context from the task inputxtx\_\{t\}:

π\(k\)\(⋅\)≜πL​L​M\(mk⊕⋅\),c0\(k\)=xt\.\\pi^\{\(k\)\}\(\\cdot\)\\;\\triangleq\\;\\pi\_\{LLM\}\(m\_\{k\}\\oplus\\,\\,\\cdot\\,\),\\qquad c^\{\(k\)\}\_\{0\}=x\_\{t\}\.\(6\)The subagent then executes an independent tool\-calling reasoning process within this separate context, following[Equations1](https://arxiv.org/html/2609.09233#S2.E1),[2](https://arxiv.org/html/2609.09233#S2.E2)and[3](https://arxiv.org/html/2609.09233#S2.E3)underπ\(k\)\\pi^\{\(k\)\}, and returns only the responserT\(k\)r^\{\(k\)\}\_\{T\}from its last turnTT:

E⁡\(k=Subagent⁡\(s\),xt\)=rT\(k\)\.E\(k=\\mathrm\{Subagent\}\(s\),x\_\{t\}\)=r^\{\(k\)\}\_\{T\}\.\(7\)
Both mechanisms draw on the same skill packagess, but they differ in which policy that knowledge conditions\. Agent skills let a single policyπL​L​M\\pi\_\{LLM\}operating over a single context, with the skill’s execution unfolding as part of the main agent’s own turn sequence; subagents introduce a separate subpolicyπ\(k\)\\pi^\{\(k\)\}per skill package, each acting on a context the main agent neither reads nor writes\. Note thatπ\(k\)\\pi^\{\(k\)\}is defined here over the same LLM as the mainπL​L​M\\pi\_\{LLM\}, but it can instead be instantiated from a different one; what makes it a separate policy is that it is separately instantiated and communicates with the main agent only through the input and output,xtx\_\{t\}andrT\(k\)r^\{\(k\)\}\_\{T\}\.

## 3Subagents For Long\-horizon Agentic Tasks

LLM reasoning capability declines with context length[Liu et al\. \(2024\)](https://arxiv.org/html/2609.09233#bib.bib7);[Du et al\. \(2025\)](https://arxiv.org/html/2609.09233#bib.bib8);[Hong et al\. \(2025\)](https://arxiv.org/html/2609.09233#bib.bib6);[Li et al\. \(2026a\)](https://arxiv.org/html/2609.09233#bib.bib5); this decline has been linked to bandwidth\-limited attention: LLMs can only communicate a bounded amount of information across long inputs[Schnabel et al\. \(2026\)](https://arxiv.org/html/2609.09233#bib.bib37)\. Long\-horizon agentic tasks are particularly susceptible to this degradation: they require agents to reason over increasingly long trajectories, consisting of verbose tool inputs and outputs, and intermediate reasoning\. While skill packages may contain useful knowledge to solve such tasks, invoking an agent skill, which loads the skill instructions into the agent’s context, amplifies the context overload issue\. Solving long\-horizon tasks may depend not only on having access to useful skills, but also on executing those skills in a way that controls context growth\. To achieve this, we explore the use ofsubagents\.

### 3\.1Reducing Peak Context Length Through Subagent Execution

To control context growth, we directly ask whether spawning more context windows can help\. What matters for bandwidth limitations discussed above is not total context consumed across a task, but the*peak*context length any single window must process\. If we can decompose a task into smaller, self\-contained subtasks and execute each subtask within a separate context window, we expect the peak context length across all these windows to be shorter than that of a single, monolithic context window\. Subagent execution encodes this exact mechanism \([Figure1](https://arxiv.org/html/2609.09233#S1.F1)\)\. When a subagent is invoked, a new context window is spawned and initialized with the subagent’s input and its skill package’s instructions\.

One way to view subagent execution is through the lens of information encapsulation\. Subagents encapsulate subtask\-specific information\. Subagents’ internal trajectories are hidden away from the main, parent agent\. Only the final output of the subagent is visible to the main agent\. The main agent then has less information to reason over, and so it can reason better\.

However, peak context reduction with subagents comes at a cost\. Executing a task across multiple context windows introduces communication overhead between the main agent and subagents \([Figure1](https://arxiv.org/html/2609.09233#S1.F1)\): since subagents do not see the main context, they must be given sufficient input information to carry out their subtask, which means relevant information is often repeated across context windows\. Subagent execution thus trades a higher total token count for reduced peak context length\.

We note that popular agent harnesses such as Claude Code and OpenAI Codex do support spawning subagents, but they tend to be used for task parallelization rather than encapsulating information[Anthropic \(2026\)](https://arxiv.org/html/2609.09233#bib.bib36)\. In many cases, the spawned subagents do not use any skill package; they function as lightweight parallel workers\. The use of subagents as a mechanism for executing reusable knowledge remains relatively underexplored\.

### 3\.2Input\-Output Contracts for Effective Subagents

Reducing peak context length with subagents is useful for agent performance*only if*the subtasks in the subcontext windows are actually solved correctly\. Unlike agent skills, subagents introduce an additional subtask delegation problem: the main agent must identify an appropriate subagent for a subtask and provide sufficient information for the subagent to solve it successfully\. If the main agent fails at either of these, subagents become ineffective\.

To ensure the main agent correctly delegates subtasks and provides required information for each subtask, each skill description needs to tell the main agent what subtask the corresponding subagent can solve and what information should be supplied to it\. Of course, the skill instructions then must match the skill description: they have to tell the subagents how to solve the subtasks the description promises to solve\.

Skill packages designed this way echo the options framework[Sutton et al\. \(1999\)](https://arxiv.org/html/2609.09233#bib.bib1): invoked as subagents, they behave as language\-based options\. An option is defined as

ω=\(ℐω,πω,βω\)\\omega=\(\\mathcal\{I\}\_\{\\omega\},\\pi\_\{\\omega\},\\beta\_\{\\omega\}\)\(8\)whereℐω\\mathcal\{I\}\_\{\\omega\}is the initiation set,πω\\pi\_\{\\omega\}is the option policy, andβω\\beta\_\{\\omega\}is the termination condition\. An option may be invoked only in states belonging toℐω\\mathcal\{I\}\_\{\\omega\}, after which it followsπω\\pi\_\{\\omega\}until termination occurs according toβω\\beta\_\{\\omega\}\.

Similarly, an effective subagent skill package should specify when the subagent can be appropriately invoked, how it solves the delegated task, and what information it returns upon completion\. We therefore structure the skill description as

d=\(qin,h,qout\)d=\(q\_\{\\mathrm\{in\}\},h,q\_\{\\mathrm\{out\}\}\)\(9\)wherehhis a concise summary of the skill’s purpose, andqinq\_\{\\mathrm\{in\}\}andqoutq\_\{\\mathrm\{out\}\}are natural\-language input and output contract specifications, respectively\.

Substituting into[Equation4](https://arxiv.org/html/2609.09233#S2.E4), the skill package is

s=\(\(qin,h,qout\),m,R\)s=\\bigl\(\(q\_\{\\mathrm\{in\}\},h,q\_\{\\mathrm\{out\}\}\),\\,m,\\,R\\bigr\)\(10\)Just as an option implementsω:ℐω→𝒯ω\\omega:\\mathcal\{I\}\_\{\\omega\}\\rightarrow\\mathcal\{T\}\_\{\\omega\}, where𝒯ω\\mathcal\{T\}\_\{\\omega\}is the set of terminal states permitted byβω\\beta\_\{\\omega\}, the contracts define sets of valid inputs𝒳in\\mathcal\{X\}\_\{\\mathrm\{in\}\}and outputs𝒳out\\mathcal\{X\}\_\{\\mathrm\{out\}\}, and the resulting subagent implementsSubagent⁡\(s\):𝒳in→𝒳out\\mathrm\{Subagent\}\(s\):\\mathcal\{X\}\_\{\\mathrm\{in\}\}\\rightarrow\\mathcal\{X\}\_\{\\mathrm\{out\}\}\. The input contractqinq\_\{\\mathrm\{in\}\}plays the role of the initiation setℐω\\mathcal\{I\}\_\{\\omega\}, specifying the conditions under which the subagent may be invoked\. The instruction filemmplays the role of the option policyπω\\pi\_\{\\omega\}, encoding the procedure that carries a valid input to an output\.qoutq\_\{\\mathrm\{out\}\}plays the role of the termination conditionβω\\beta\_\{\\omega\}, constraining what the subagent returns to the main agent\. These contracts define a self\-contained interface through which information enters and leaves the subagent\. We therefore hypothesize that procedural instructions coupled with explicit input\-output contracts enable effective subagent execution\.

## 4Experiments

We now test the claims made in[Section3](https://arxiv.org/html/2609.09233#S3)\.[Section3\.2](https://arxiv.org/html/2609.09233#S3.SS2)claims that subagents help only when skill packages expose explicit input\-output contracts and pair them with instructions that faithfully deliver on those contracts, and[Section3\.1](https://arxiv.org/html/2609.09233#S3.SS1)claims that subagents then trade higher total tokens for lower peak context\. We test the contract claim first, comparing both execution strategies on existing curated and our contract\-based skill packages\. We then increase context pressure by adding distracting tools, testing whether the advantage of subagents grows with context length\. Finally, we measure peak context and total token cost directly\.

#### Domain: SkillsBench\.

SkillsBench[Li et al\. \(2026b\)](https://arxiv.org/html/2609.09233#bib.bib9)is a benchmark specifically designed to evaluate the effectiveness of agent skills, comprising 87 long\-horizon agentic tasks across diverse domains\. Each task comes with a set of human\-authored skill packages, which lets us test agent\-skill and subagent execution under a curated set of packages\.

We use OpenHands[Wang et al\. \(2025\)](https://arxiv.org/html/2609.09233#bib.bib10)as the agent harness throughout this paper, with limited modifications to the original OpenHands SDK; details can be founded at[SectionA\.3](https://arxiv.org/html/2609.09233#A1.SS3)\.

#### Synthesizing procedural skill packages with explicit input\-output contracts\.

From inspecting the curated SkillsBench skill packages, we find that very few satisfy the criteria for effective subagent execution discussed in[Section3\.2](https://arxiv.org/html/2609.09233#S3.SS2)\. In particular, most packages describe relevant information but do not clearly specify the inputs expected by the skill or the outputs it should produce\.

To construct skill packages better suited for subagent execution, we create a new set of procedural skill packages with explicit input\-output contracts for each task\. Specifically, we first run OpenHands agents[Wang et al\. \(2025\)](https://arxiv.org/html/2609.09233#bib.bib10)using GPT\-5\.3 Codex on all SkillsBench tasks for three independent runs, collect successful trajectories, and use Copilot CLI[GitHub \(2026\)](https://arxiv.org/html/2609.09233#bib.bib29), with minimal human intervention, to synthesize skill packages\. Using this procedure, we successfully synthesize these well\-interfaced procedural skill packages for 64 of the 87 benchmark tasks\. More details can be founded at[SectionA\.4](https://arxiv.org/html/2609.09233#A1.SS4)\. The results of this paper are on this 64\-task subset of SkillsBench\. From now on, we refer to this skill package set as the*synthesized*set\.

Figure 2:Average task accuracy on SkillsBench for each execution mode \(agent skill / subagent\) and skill package set, across base LLM models\. The*no I/O contracts*packages are the human\-authored ones curated with SkillsBench, which describe relevant knowledge but rarely specify a skill’s expected inputs or outputs\. The*procedural \+ I/O contracts*packages are ours, synthesized from successful trajectories to give procedural instructions with explicit input\-output contracts\.
#### Main results\.

[Figure2](https://arxiv.org/html/2609.09233#S4.F2)shows the main comparison between agent skills and subagents\. When using the original curated SkillsBench skills, which lack input\-output contracts, agent skills match or outperform subagents across all models\. However, the trend reverses when using our procedural skill packages with explicit input\-output contracts\. On these skill packages, subagents outperform agent skills, with the gain being largest for smaller models that are more bandwidth limited\.

This result supports our central hypothesis: subagent execution becomes beneficial when skills are designed as procedural abstractions with well\-defined interfaces\. In contrast, when skills primarily contain loosely structured knowledge, directly injecting the skill contents into the main agent’s context, i\.e\., agent skill execution, is more effective\.

Finally, our synthesized skill packages outperform the curated ones across both execution modes\. This is not a controlled comparison, since the two sets differ in content, but it suggests that the synthesis procedure produces skills of at least comparable quality to the curated ones\.

Figure 3:Average task accuracy vs number of distracting skills for each base LLM model and execution mode\. The skill packages used are from our synthesized set\. Only three LLMs are displayed here for readability, see the full plot at[Figure6](https://arxiv.org/html/2609.09233#A1.F6)\.
#### Scaling with increasing context information\.

We next study how both execution strategies scale as input size grows and context pressure intensifies\. To do so, we introduce distracting tools whose descriptions are appended to the agent context but are not required for solving the task\. This simulates a realistic setting in which agents operate in environments containing many available tools\. As the number of distracting tools increases, the initial context becomes substantially longer\.

[Figure3](https://arxiv.org/html/2609.09233#S4.F3)\(right\) shows that subagent execution degrades more gracefully as the number of distracting tools increases\. This confirms the benefit of peak context reduction discussed in[Section3\.1](https://arxiv.org/html/2609.09233#S3.SS1): keeping skill instructions out of an already\-large context matters even more as that context grows\.

Figure 4:Left: The percentage of tasks whose peak context length used is lower for subagent execution than agent skill execution\. Right: Total token used by each execution mode for each LLM model\. The skill packages used are from our synthesized set for both left and right figures\.
#### Peak context length and total token cost\.

We now test our claim \([Section3\.1](https://arxiv.org/html/2609.09233#S3.SS1)\) that subagents trade communication overhead for reduced peak context\.

[Figure4](https://arxiv.org/html/2609.09233#S4.F4)\(left\) shows that for the stronger models, such as GPT 5\.3 Codex and Kimi K2\.6, subagents lower peak context length on over 80% of tasks, as predicted\.

For weaker models, the reduction is smaller and sometimes reverses\. This appears to reflect early termination under agent\-skill execution: as the agent’s reasoning degrades, the run ends without spending enough reasoning effort on the task, so its context stays short\. Subagent runs behave differently—each subagent works on a single coherent subtask and can spend the tokens needed to complete it\. Peak context length is therefore only comparable across models whose success rates are similar under both execution modes, which the stronger models satisfy and the weaker ones do not\.

[Figure4](https://arxiv.org/html/2609.09233#S4.F4)\(right\) shows the corresponding token cost\. Subagent execution consumes substantially more tokens overall, as expected: an agent skill leaves all information in a single context, while each subagent must be supplied the context it needs, duplicating information the main agent already holds\.

## 5Related Work

#### Tool\-Calling Language Model Agents\.

LLMs have become powerful agents when augmented with tools\. ReAct interleaves tool use with reasoning through prompting[Yao et al\. \(2023\)](https://arxiv.org/html/2609.09233#bib.bib20), while Toolformer, Gorilla, and ToolLLM instead train models to use tools, fine\-tuning them to decide when to call a tool and to generate correct calls[Schick et al\. \(2023\)](https://arxiv.org/html/2609.09233#bib.bib21);[Patil et al\. \(2024\)](https://arxiv.org/html/2609.09233#bib.bib22);[Qin et al\. \(2024\)](https://arxiv.org/html/2609.09233#bib.bib23)\. Closely related to our work is HuggingGPT, which uses other LLMs as tools, orchestrated by a central LLM controller[Shen et al\. \(2023\)](https://arxiv.org/html/2609.09233#bib.bib24), similar to how subagents act as LLM\-based tools in our setting; unlike our work, however, it does not study skill package execution\.

While early tool calling benchmarks evaluated single\-turn API routing[Li et al\. \(2023\)](https://arxiv.org/html/2609.09233#bib.bib25);[Patil et al\. \(2025\)](https://arxiv.org/html/2609.09233#bib.bib26), real\-world use increasingly demands long, stateful interactions across many tools and applications[Yao et al\. \(2024\)](https://arxiv.org/html/2609.09233#bib.bib28);[Barres et al\. \(2025\)](https://arxiv.org/html/2609.09233#bib.bib27);[Li et al\. \(2026b\)](https://arxiv.org/html/2609.09233#bib.bib9);[Li et al\. \(2026a\)](https://arxiv.org/html/2609.09233#bib.bib5)\. Tasks in SkillsBench, for example, require many tool\-calling turns, accumulate substantial information in context, and thus demand methods that scale with context size\.

#### LLM Skill Learning\.

Skill learning for LLM agents originally focused on programmatic skills\. Voyager[Wang et al\. \(2023\)](https://arxiv.org/html/2609.09233#bib.bib2)grows a library of executable code skills for a Minecraft agent\. LATM[Cai et al\. \(2024\)](https://arxiv.org/html/2609.09233#bib.bib17), CREATOR[Qian et al\. \(2023\)](https://arxiv.org/html/2609.09233#bib.bib18), and CRAFT[Yuan et al\. \(2024\)](https://arxiv.org/html/2609.09233#bib.bib19)instead frame skill acquisition as tool creation, having an LLM author reusable code tools\. More recently, SkillCraft[Chen et al\. \(2026\)](https://arxiv.org/html/2609.09233#bib.bib15)learns programmatic skills by composing a sequence of tool calls into skills and benchmarks skill reuse\.

Following the wide adoption of skill packages as a skill format[Anthropic \(2025\)](https://arxiv.org/html/2609.09233#bib.bib4), we have seen a surge of skill\-package learning papers that construct or refine multi\-file skill folders directly from agent experience[Alzubi et al\. \(2026\)](https://arxiv.org/html/2609.09233#bib.bib11);[Zhang et al\. \(2026\)](https://arxiv.org/html/2609.09233#bib.bib12);[Ni et al\. \(2026\)](https://arxiv.org/html/2609.09233#bib.bib13)\. At their core, these methods mine execution trajectories or failures and use them to synthesize skill packages\. These works all execute skill packages as agent skills\. Our work also uses skill packages but does not focus on skill\-package learning; instead, we show that when skill packages are written or learned to follow a certain design, subagents can be used effectively, and they scale well with context size\.

## 6Conclusion and Future Work

We studied how reusable skill packages should be executed in long\-horizon agentic tasks\. While agent skills execute by loading skill instructions into the main agent context, subagents execute skills in separate contexts and return only their outputs\. We find that when context overload is an issue, subagent execution performs better and degrades more gracefully than agent skill execution as initial context scales\. By distributing computation across multiple context windows, subagents reduce the amount of information that any single context must process\.

However, there are limitations to subagent execution\. Our experiments suggest that subagents work well only when skill packages encode procedural knowledge with clear input\-output contracts\. Such skills can be executed largely independently of the main agent’s context, making them suitable for encapsulation in a separate context\. Existing curated skills do not always exhibit this property\. Nevertheless, we show that procedural, contract\-driven skills can be synthesized from successful trajectories, suggesting a practical pathway for learning skills that are suited to subagent execution\.

More broadly, our results suggest that scaling agent systems requires reducing context load\. Modularity helps control information flow by encapsulating task\-specific knowledge behind clear interfaces\. From this perspective, subagent execution can be viewed as a mechanism for enforcing modularity\.

Looking forward, two directions deserve further investigation\. First, while subagent execution reduces peak context length, it incurs additional communication cost, raising the question of how the main agent and subagents should communicate efficiently—designing skills with minimal contracts is one concrete route, but the general problem remains open\. Second, we have only begun to explore the problem of skill library organization \([SectionA\.1](https://arxiv.org/html/2609.09233#A1.SS1)\)\. Future work could investigate the notion of skill\-library refactoring: how should reusable procedures be abstracted, factored, and organized as a skill library grows? In the same way that software engineering studies how large codebases should be structured, scalable agent systems may require principled approaches for organizing procedural knowledge hierarchically\.

## References

- \[1\]E\. H\. Shortliffe\(1976\)Computer\-based medical consultations: mycin\.\.Annals of Internal Medicine85\(6\),pp\. 831–831\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p1.1)\.
- \[2\]D\. B\. Lenat\(1995\)CYC: a large\-scale investment in knowledge infrastructure\.Communications of the ACM38\(11\),pp\. 33–38\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p1.1)\.
- \[3\]R\. J\. Brachman, H\. J\. Levesque, and M\. Pagnucco\(2004\)Knowledge representation and reasoning\.Vol\.1,Elsevier\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p1.1)\.
- \[4\]R\. Speer, J\. Chin, and C\. Havasi\(2017\)Conceptnet 5\.5: an open multilingual graph of general knowledge\.InProceedings of the AAAI conference on artificial intelligence,Vol\.31\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p1.1)\.
- \[5\]Anthropic\(2025\)Agent Skills\.Note:[https://platform\.claude\.com/docs/en/agents\-and\-tools/agent\-skills/overview](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)Accessed: 2026\-08\-08Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p2.1),[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p2.1)\.
- \[6\]R\. S\. Sutton, D\. Precup, and S\. Singh\(1999\)Between mdps and semi\-mdps: a framework for temporal abstraction in reinforcement learning\.Artificial intelligence112\(1\-2\),pp\. 181–211\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p3.1),[§1](https://arxiv.org/html/2609.09233#S1.p5.1),[§3\.2](https://arxiv.org/html/2609.09233#S3.SS2.p3.1)\.
- \[7\]R\. Parr and S\. Russell\(1997\)Reinforcement learning with hierarchies of machines\.Advances in neural information processing systems10\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p3.1)\.
- \[8\]T\. G\. Dietterich\(2000\)Hierarchical reinforcement learning with the maxq value function decomposition\.Journal of artificial intelligence research13,pp\. 227–303\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p3.1)\.
- \[9\]N\. F\. Liu, K\. Lin, J\. Hewitt, A\. Paranjape, M\. Bevilacqua, F\. Petroni, and P\. Liang\(2024\)Lost in the middle: how language models use long contexts\.Transactions of the association for computational linguistics12,pp\. 157–173\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p3.1),[§3](https://arxiv.org/html/2609.09233#S3.p1.1)\.
- \[10\]Y\. Du, M\. Tian, S\. Ronanki, S\. Rongali, S\. Bodapati, A\. Galstyan, A\. Wells, R\. Schwartz, E\. A\. Huerta, and H\. Peng\(2025\)Context length alone hurts llm performance despite perfect retrieval\.arXiv preprint arXiv:2510\.05381\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p3.1),[§3](https://arxiv.org/html/2609.09233#S3.p1.1)\.
- \[11\]E\. Hong, S\. Cho, and J\. Kim\(2025\)Exploring working memory capacity in llms: from stressors to human\-inspired strategies\.InProceedings of the 14th International Joint Conference on Natural Language Processing and the 4th Conference of the Asia\-Pacific Chapter of the Association for Computational Linguistics,pp\. 1727–1744\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p3.1),[§3](https://arxiv.org/html/2609.09233#S3.p1.1)\.
- \[12\]J\. Li, W\. Zhao, J\. Zhao, W\. Zeng, H\. Wu, X\. Wang, R\. Ge, Y\. Cao, Y\. Huang, W\. Liu,et al\.\(2026\)The tool decathlon: benchmarking language agents for diverse, realistic, and long\-horizon task execution\.InInternational Conference on Learning Representations,Vol\.2026,pp\. 53359–53394\.Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p3.1),[§3](https://arxiv.org/html/2609.09233#S3.p1.1),[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p2.1)\.
- \[13\]Anthropic\(2026\)How and when to use subagents in Claude Code\.Note:Accessed: 2026\-09\-04External Links:[Link](https://claude.com/blog/subagents-in-claude-code)Cited by:[§1](https://arxiv.org/html/2609.09233#S1.p4.1),[§3\.1](https://arxiv.org/html/2609.09233#S3.SS1.p4.1)\.
- \[14\]T\. Schnabel, K\. Tomlinson, A\. Swaminathan, and J\. Neville\(2026\)Lost in transmission: when and why llms fail to reason globally\.Advances in Neural Information Processing Systems38,pp\. 138944–138982\.Cited by:[§3](https://arxiv.org/html/2609.09233#S3.p1.1)\.
- \[15\]X\. Li, Y\. Liu, W\. Chen, B\. You, Z\. Di, Y\. He, S\. Zheng, K\. W\. Choe, J\. Sun, S\. Wang,et al\.\(2026\)SkillsBench: benchmarking how well agent skills work across diverse tasks\.arXiv preprint arXiv:2602\.12670\.Cited by:[§4](https://arxiv.org/html/2609.09233#S4.SS0.SSS0.Px1.p1.1),[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p2.1)\.
- \[16\]X\. Wang, B\. Li, Y\. Song, F\. F\. Xu, X\. Tang, M\. Zhuge, J\. Pan, Y\. Song, B\. Li, J\. Singh,et al\.\(2025\)Openhands: an open platform for ai software developers as generalist agents\.InInternational Conference on Learning Representations,Vol\.2025,pp\. 65882–65919\.Cited by:[§A\.3](https://arxiv.org/html/2609.09233#A1.SS3.p1.1),[§4](https://arxiv.org/html/2609.09233#S4.SS0.SSS0.Px1.p2.1),[§4](https://arxiv.org/html/2609.09233#S4.SS0.SSS0.Px2.p2.1)\.
- \[17\]GitHub\(2026\)GitHub Copilot CLI\.Note:[https://github\.com/github/copilot\-cli](https://github.com/github/copilot-cli)Accessed: 2026\-08\-31Cited by:[§4](https://arxiv.org/html/2609.09233#S4.SS0.SSS0.Px2.p2.1)\.
- \[18\]S\. Yao, J\. Zhao, D\. Yu, N\. Du, I\. Shafran, K\. Narasimhan, and Y\. Cao\(2023\)ReAct: synergizing reasoning and acting in language models\.InInternational Conference on Learning Representations \(ICLR\),Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p1.1)\.
- \[19\]T\. Schick, J\. Dwivedi\-Yu, R\. Dessì, R\. Raileanu, M\. Lomeli, E\. Hambro, L\. Zettlemoyer, N\. Cancedda, and T\. Scialom\(2023\)Toolformer: language models can teach themselves to use tools\.Advances in neural information processing systems36,pp\. 68539–68551\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p1.1)\.
- \[20\]S\. G\. Patil, T\. Zhang, X\. Wang, and J\. E\. Gonzalez\(2024\)Gorilla: large language model connected with massive apis\.Advances in Neural Information Processing Systems37,pp\. 126544–126565\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p1.1)\.
- \[21\]Y\. Qin, S\. Liang, Y\. Ye, K\. Zhu, L\. Yan, Y\. Lu, Y\. Lin, X\. Cong, X\. Tang, B\. Qian,et al\.\(2024\)Toolllm: facilitating large language models to master 16000\+ real\-world apis\.InInternational Conference on Learning Representations,Vol\.2024,pp\. 9695–9717\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p1.1)\.
- \[22\]Y\. Shen, K\. Song, X\. Tan, D\. Li, W\. Lu, and Y\. Zhuang\(2023\)Hugginggpt: solving ai tasks with chatgpt and its friends in hugging face\.Advances in Neural Information Processing Systems36,pp\. 38154–38180\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p1.1)\.
- \[23\]M\. Li, Y\. Zhao, B\. Yu, F\. Song, H\. Li, H\. Yu, Z\. Li, F\. Huang, and Y\. Li\(2023\)Api\-bank: a comprehensive benchmark for tool\-augmented llms\.InProceedings of the 2023 conference on empirical methods in natural language processing,pp\. 3102–3116\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p2.1)\.
- \[24\]S\. G\. Patil, H\. Mao, F\. Yan, C\. C\. Ji, V\. Suresh, I\. Stoica, and J\. E\. Gonzalez\(2025\)The berkeley function calling leaderboard \(bfcl\): from tool use to agentic evaluation of large language models\.InForty\-second International Conference on Machine Learning,Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p2.1)\.
- \[25\]S\. Yao, N\. Shinn, P\. Razavi, and K\. Narasimhan\(2024\)τ\\tau\-Bench: a benchmark for tool\-agent\-user interaction in real\-world domains\.External Links:2406\.12045,[Link](https://arxiv.org/abs/2406.12045)Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p2.1)\.
- \[26\]V\. Barres, H\. Dong, S\. Ray, X\. Si, and K\. Narasimhan\(2025\)τ2\\tau^\{2\}\-Bench: evaluating conversational agents in a dual\-control environment\.External Links:2506\.07982,[Link](https://arxiv.org/abs/2506.07982)Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px1.p2.1)\.
- \[27\]G\. Wang, Y\. Xie, Y\. Jiang, A\. Mandlekar, C\. Xiao, Y\. Zhu, L\. Fan, and A\. Anandkumar\(2023\)Voyager: an open\-ended embodied agent with large language models\.arXiv preprint arXiv: Arxiv\-2305\.16291\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p1.1)\.
- \[28\]T\. Cai, X\. Wang, T\. Ma, X\. Chen, and D\. Zhou\(2024\)Large language models as tool makers\.InInternational Conference on Learning Representations,Vol\.2024,pp\. 54067–54089\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p1.1)\.
- \[29\]C\. Qian, C\. Han, Y\. Fung, Y\. Qin, Z\. Liu, and H\. Ji\(2023\)Creator: tool creation for disentangling abstract and concrete reasoning of large language models\.InFindings of the Association for Computational Linguistics: EMNLP 2023,pp\. 6922–6939\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p1.1)\.
- \[30\]L\. Yuan, Y\. Chen, X\. Wang, Y\. Fung, H\. Peng, and H\. Ji\(2024\)Craft: customizing llms by creating and retrieving from specialized toolsets\.InInternational Conference on Learning Representations,Vol\.2024,pp\. 40097–40125\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p1.1)\.
- \[31\]S\. Chen, J\. Gai, R\. Zhou, J\. Zhang, T\. Zhu, J\. Li, K\. Wang, Z\. Wang, Z\. Chen, K\. Kaleb,et al\.\(2026\)Skillcraft: can llm agents learn to use tools skillfully?\.arXiv preprint arXiv:2603\.00718\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p1.1)\.
- \[32\]S\. Alzubi, N\. Provenzano, J\. Bingham, W\. Chen, and T\. Vu\(2026\)Evoskill: automated skill discovery for multi\-agent systems\.arXiv preprint arXiv:2603\.02766\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p2.1)\.
- \[33\]H\. Zhang, S\. Fan, H\. P\. Zou, Y\. Chen, Z\. Wang, J\. Zhou, C\. Li, W\. Huang, Y\. Yao, K\. Zheng,et al\.\(2026\)Coevoskills: self\-evolving agent skills via co\-evolutionary verification\.arXiv preprint arXiv:2604\.01687\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p2.1)\.
- \[34\]J\. Ni, Y\. Liu, X\. Liu, Y\. Sun, M\. Zhou, P\. Cheng, D\. Wang, E\. Zhao, X\. Jiang, and G\. Jiang\(2026\)Trace2skill: distill trajectory\-local lessons into transferable agent skills\.arXiv preprint arXiv:2603\.25158\.Cited by:[§5](https://arxiv.org/html/2609.09233#S5.SS0.SSS0.Px2.p2.1)\.
- \[35\]Y\. Liu, J\. Hu, Y\. Shan, G\. Li, Y\. Zou, Y\. Dong, and T\. Xie\(2025\)LLMigrate: transforming" lazy" large language models into efficient source code migrators\.arXiv preprint arXiv:2503\.23791\.Cited by:[§A\.2](https://arxiv.org/html/2609.09233#A1.SS2.p2.1)\.
- \[36\]P\. Xia, J\. Chen, H\. Wang, J\. Liu, K\. Zeng, Y\. Wang, S\. Han, Y\. Zhou, X\. Zhao, H\. Chen,et al\.\(2026\)Skillrl: evolving agents via recursive skill\-augmented reinforcement learning\.arXiv preprint arXiv:2602\.08234\.Cited by:[§A\.5](https://arxiv.org/html/2609.09233#A1.SS5.p2.1)\.
- \[37\]C\. Wang, Z\. Yu, X\. Xie, W\. Yao, R\. Fang, S\. Qiao, K\. Cao, G\. Zheng, X\. Qi, P\. Zhang,et al\.\(2026\)Skillx: automatically constructing skill knowledge bases for agents\.arXiv preprint arXiv:2604\.04804\.Cited by:[§A\.5](https://arxiv.org/html/2609.09233#A1.SS5.p2.1)\.

## Appendix AAppendix

### A\.1Organizing Libraries of Skills to Decrease Initial Context Load

We next ask whether hierarchically organizing a skill library can amplify the benefits of context isolation\. Recent agent systems increasingly lazy\-load MCP servers, exposing capabilities only when needed, which keeps the initial context short and lowers peak context length in later turns\. We test an analogous strategy for skill libraries: rather than exposing every skill at once, we organize skills into a hierarchy and expose only a subset at each level\.

#### Library organization\.

When a library contains many skills, exposing all of them to the agent at once can be overwhelming for the agent\. A hierarchical library instead exposes only a small set of top\-level nodes at first; selecting a node either performs a task \(if it is a leaf skill\) or reveals a further set of child nodes to choose from \(if it is a*routing*node\)\. The agent navigates the hierarchy step by step rather than seeing the whole library up front\. We compare four different library organizations, all with the leaf nodes being the well\-interfaced procedural skills evaluated in[Figure2](https://arxiv.org/html/2609.09233#S4.F2):

- •Flat library\.No hierarchy: all leaf skills are exposed to the agent simultaneously\. This is the baseline used throughout[Figure2](https://arxiv.org/html/2609.09233#S4.F2)\.
- •Hierarchical tree library\.An LLM groups the leaf skills into a tree of routing nodes, where each routing node has exactly one parent, so there is a single path from the root to any leaf\.
- •Hierarchical graph library\.The same LLM\-built organization as the tree library, except a node may have multiple parents, so the structure is a DAG rather than a tree and a leaf can be reached via more than one path\.
- •Two\-level task\-tree library\.A simpler baseline \(no LLM involved\): leaf skills are grouped by the task they belong to, giving a fixed two\-level hierarchy of task node to leaf skills\.

#### Execution modes\.

Independently of library structure, we vary how nodes are executed once selected:

- •Fully agent skill:every node, routing or leaf, runs inline in the main agent’s context\.
- •Fully subagent:every node runs as an isolated subagent call\.
- •Hybrid:routing \(higher\-level\) nodes run as agent skills, while leaf skills run as subagents\.

#### Results\.

[Figure5](https://arxiv.org/html/2609.09233#A1.F5)shows that hierarchical organization gives additional gains on top of our already well\-interfaced procedural skill packages\. The task\-tree and hierarchical\-graph libraries perform best, and the LLM\-built graph outperforms the LLM\-built tree, suggesting that allowing multiple paths to a leaf skill helps\. We did not observe further gains from deeper hierarchies in our experiments, though we expect benefits from deeper structure to emerge with libraries of thousands of skills\.

Across all four library types, the hybrid execution mode is consistently best: routing nodes as agent skills, leaf skills as subagents\. This mirrors lazy\-loading in MCP\-based harnesses and supports our broader*effective subagent hypothesis*: routing nodes carry no procedural knowledge or clear input\-output contract, so they are better executed inline as agent skills, while leaf skills – which do have such contracts – benefit from running as isolated subagents\. We leave a systematic study of deeper hierarchies and tree\-vs\-graph structure to future work\.

Figure 5:Average task accuracy on SkillsBench for each library organization \(flat, hierarchical tree, hierarchical graph, and two\-level task tree\) and execution mode \(fully agent skill / fully subagent / hybrid\) on Qwen3\.5\-9B\.*h2*and*h3*means height=2 and height=3 respectively\.

### A\.2Additional results on SkillsBench

Here, we include the average task accuracy vs number of distracting skills plot, for[Section4](https://arxiv.org/html/2609.09233#S4.SS0.SSS0.Px4), with more base models\. The interpretation of the results remains the same; we choose to only include only three LLMs in the main text for better readability\.

We also report number of skill calls per task at[Figure7](https://arxiv.org/html/2609.09233#A1.F7)\. We see that subagent execution leads to more skill calls per task across all base LLMs\. With agent\-skill execution, we think that the LLMs start to underthink as their context grows\[[35](https://arxiv.org/html/2609.09233#bib.bib30)\], leading to lower skill calls on average\.

Figure 6:Average task accuracy vs number of distracting skills for each base LLM model and execution mode\. The skill packages used are from our synthesized set\.Figure 7:Number of skill calls for each base LLM model\. The skill packages used are from our synthesized set\.
### A\.3OpenHands Agent Implementation Details

We use OpenHands\[[16](https://arxiv.org/html/2609.09233#bib.bib10)\]as one of the underlying agent frameworks in our experiments\. When running each SkillsBench task, we spin up a docker container and run OpenHands agent inside the task’s Docker container as the benchmark harness’s registered agent\. We route every LLM call through a proxy that we control, which lets us inject system prompts, apply sampling overrides, and log every request/response pair uniformly\.

#### Prompt templates\.

We replace the Openhands’ own vanilla system prompt with a much simpler prompt shown at[Figure8](https://arxiv.org/html/2609.09233#A1.F8)\. When subagents get spawned, they are initialized with the prompt shown at[Figure9](https://arxiv.org/html/2609.09233#A1.F9)\.

Default system prompt \(simple\)```
You are AI agents with access to tools. Please solve the
user-specified task as best as you can. Please always use
tools whenever they are relevant -- don’t try to solve
subtasks on your own. Please try to use the <tool1>, <tool2>, ...
when possible.
```

Figure 8:The system prompt used for our OpenHands agent\.*tool1*,*tool2*, and so on list the name of the skills \(agent skills / subagents\) available\.Subagent task template```
You will be given a task and the knowledge on how to solve it

TASK:
{task}

INPUT INFORMATION:                 [only when input_info is non-empty]
{input_info}

KNOWLEDGE:
{skill_body}

Resources mentioned in KNOWLEDGE are available at: {skill_dir}

IMPORTANT: When you are done, return the output this skill
produces in your FINAL message. If the output is a file (or
files) you created or edited, state its exact path in your
final message; otherwise put the actual result text in your
final message. Do not end without reporting the output.
```

Figure 9:Initial prompt for a spawned subagent\.*skill\_body*is the content in a SKILL\.md file\.*task*and*input\_info*are given to the subagent by the main agent\.
#### Other modifications to vanilla OpenHands SDK

We also implement two modifications to the vanilla OpenHand SDK\. First is we extend the subagent timeout\. The OpenHands SDK hardcodes a 5\-min timeout on every MCP tool call\. Since our subagents are treated as MCP tools, we extend this timeout to two hours\. Second is we remove OpenHands’ native skills\. We also disable OpenHands’ native auto\-skill retrieval\.

Skill vulnerability\-record\-normalization description```
Convert scanner JSON into normalized CSV-ready vulnerability records
using the task severity filter and deterministic CVSS/fixed-version
fallbacks.
Expected input:
    - the scanner JSON report path from the scan step
    - the required severity filter and CSV columns from the audit plan
Output:
    - a JSON list of normalized records with Package, Version, CVE_ID,
    Severity, CVSS_Score, Fixed_Version, Title, and Url fields.
```

Figure 10:A description of a well\-interfaced procedural skill, vulnerability\-record\-normalizationSkill offline\-vulnerability\-scan description```
Run a reproducible vulnerability scan for a dependency lockfile and save
the full scanner result as JSON for later normalization.
Expected input:
    - the audit plan containing the dependency lockfile path and desired
    JSON report path
    - the scanner/cache strategy, including any local Trivy cache
    directory if available
Output:
    - a JSON vulnerability report saved on disk plus a summary of total
    findings and counts by severity.
```

Figure 11:A description of a well\-interfaced procedural skill, offline\-vulnerability\-scan

### A\.4Well\-interfaced Procedural Skill Authoring details

As mentioned in[Section4](https://arxiv.org/html/2609.09233#S4), we mainly use Copilot CLI, powered by Claude Opus 5, to come up with our well\-interfaced procedural skill packages\. Initially, we ask Copilot CLI to come up with a set of 3\-5 of such skill packages for a single task, called edit\-pdf\. Then, we manually intervene to ensure the the synthesized skills do have an "expected input" and "output" description, as part of their skill description, and the skill instructions faithfully try to transform the input to output\. Then, we ask Copilot CLI to spawn subagents to do write a set of 3\-5 well\-interfaced procedural skill packages for each of the task with successful trajectories, using the skill set from the initial task, edit\-pdf, as an example\. Copilot CLI uses GPT\-5\.5 to power the subagents\.

We show an example output skill descriptions from this process at[Figures10](https://arxiv.org/html/2609.09233#A1.F10)and[11](https://arxiv.org/html/2609.09233#A1.F11)\.

### A\.5Computational Resources

Experiments were run on NVIDIA A100 GPU nodes\. Open\-weight models \(the Qwen3\.5 family at 2B/4B/9B parameters, Ministral\-3\-8B, and Gemma\-4\-12B\-it\) were served locally with vLLM directly on an A100 node’s GPU\. Closed\-weight or large models\(the GPT\-5\.x family, Mistral\-Large\-3, Kimi\-K2\.6\) were accessed through a hosting API and requires no GPU itself\.