Subagents vs. Skill Packages: The Optimal Execution Strategy for Long-Horizon Tasks

Introduction: How Can Agents Efficiently Reuse Knowledge?

When a language model agent faces complex, long-horizon tasks, a fundamental question arises: how should it effectively leverage a reusable knowledge base to solve problems? Recently, both academic and engineering communities have shown growing interest in the concept of "Agent Skills" — encapsulating reusable capabilities as skill packages (Skill Packages), which are multi-file collections containing instructions, scripts, and other resources that help agents complete specific tasks.

However, a recent arXiv paper (arXiv:2609.09233) challenges the mainstream approach to executing skill packages and proposes a more robust alternative: invoking skill packages as subagents. This research reveals a long-overlooked truth — the value of reusable knowledge depends not only on its content, but equally on how it is organized and invoked.

The Problem with Traditional Skill Packages: Context Contamination

How Skill Packages Work

In current mainstream implementations, agent skills are typically executed by loading skill instructions into the agent's context window, then relying on the agent itself to understand and follow those instructions. This approach is intuitive and easy to implement — you simply insert a "how-to" guide into the model's input and let it follow along.

Reasoning Degradation in Long-Horizon Tasks

The problem is that as task horizon increases, this method becomes increasingly fragile. The reason: reasoning quality degrades as information accumulates in the context window. As more skill instructions, intermediate results, and interaction history pile up in the same context, the model's attention gets diluted, critical information gets buried, and reasoning errors follow.

This reflects a fundamental limitation of current large language models: while context windows continue to grow (from thousands to millions of tokens), a "longer context" does not equal "better reasoning." Information overload becomes a burden rather than an asset. For long-horizon tasks requiring multi-step, extended reasoning chains, this flaw is amplified enormously.

The Subagent Approach: Trading Context Isolation for Reasoning Clarity

Core Design Philosophy

The paper's proposed alternative is elegantly simple: rather than loading skill instructions into the main agent's context, invoke the skill package as an independent subagent. Subagent execution opens a fresh, dedicated context window for resolving each individual subtask.

This means every subtask is handled in a "clean" environment, free from the interference of accumulated information in the main task. The main agent is responsible only for task decomposition and coordination, while the concrete execution details are handled by subagents with their own isolated contexts. This architecture is fundamentally an expression of the Separation of Concerns design philosophy.

Two Prerequisites for Subagents to Outperform Skill Packages

The research arrives at a clear conclusion: when skill packages satisfy the following two conditions, the subagent execution approach significantly outperforms the traditional skill package approach:

• Clear Input-Output Contracts: The interfaces exposed by the skill package are sufficiently well-defined — the main agent knows exactly what to pass in and what to expect back.
• Complete Procedural Knowledge: The skill package's instructions encode all the operational steps required to fulfill those contracts.

In other words, when a skill package behaves like a "black-box function" with a well-defined signature and internal implementation, running it as an independent subagent is the optimal choice. This aligns closely with the modularity and encapsulation principles in software engineering.

Trade-offs: The Communication Overhead of Subagents

There's no such thing as a free lunch. The primary cost of the subagent approach is additional communication overhead. Because the main agent and subagents must coordinate with each other — passing task descriptions and returning execution results — this consumes extra tokens.

This represents a classic engineering trade-off:

Execution Approach	Key Advantage	Main Drawback
Direct skill package loading	No additional communication cost	Context contamination; reasoning degrades on long-horizon tasks
Subagent invocation	Context isolation; high reasoning quality	Coordination requires additional token overhead

In practice, developers must judge based on task complexity and length: if a task is sufficiently long and complex, the reasoning quality gains from subagent isolation justify the communication cost. Conversely, for simple short-horizon tasks, direct loading may be more economical.

The Deeper Insight: How Knowledge Organization Determines Agent Effectiveness

Perhaps the most insightful conclusion of this research is: the benefit of reusable knowledge depends not only on its content, but also on how it is organized and invoked.

This insight has profound implications for AI agent architecture design as a whole. For a long time, the industry's focus has been on the "knowledge content" itself — how to write better prompts, more detailed skill instructions. But this paper reminds us that the same knowledge, organized and invoked in different ways, can yield dramatically different results.

Practical Guidance for Agent Framework Design

As various Agent frameworks continue to emerge, managing and scheduling reusable capabilities has become a central challenge. This research offers three clear principles for framework designers:

1. Prioritize designing skill modules with clear contracts, rather than vague "prompt snippets."
2. For long-horizon tasks, adopt a subagent architecture to isolate context and prevent reasoning degradation from information overload.
3. Dynamically balance communication overhead against reasoning quality, choosing execution strategies flexibly based on task characteristics rather than applying a one-size-fits-all approach.

Conclusion: From Monolithic Brain to Distributed Collaboration

The shift from "direct skill package loading" to "subagent invocation" is more than a technical implementation detail — it represents an evolution in how we think about agent architecture. It brings the battle-tested software engineering principles of modularity, isolation, and contracts into the world of large language model agents.

As agents take on increasingly complex tasks with longer time horizons, how knowledge is organized and invoked will matter just as much as the quality of the knowledge itself. This paper opens a new window for thinking about agent architecture — future agent systems may look less like a single "super-brain" and more like a carefully designed distributed software system.