Some AI skills do one tiny job; others cover a whole multi-step process. How does that difference change what they can handle?
How do composite workflow and recurring pattern skills differ from atomic operation skills in scope?
This explores how skills that cover a whole multi-step workflow, or a pattern that recurs across many tasks, differ in reach from skills that do one small operation, such as a single step or tool call.
This explores how workflow-sized and pattern-sized skills differ in reach from single-operation skills. The corpus has no note that defines this three-way split directly, but several notes describe its pieces, and together they show that scope means two different things. The first is how many steps a skill spans. The second is how many situations it applies to. An atomic skill handles one sub-task. A composite workflow skill covers the ordering and dependencies between sub-tasks. How should agents route across thousands of skills? frames the routing problem this way: real tasks need several skills together, so the agent breaks a request into atomic sub-tasks, retrieves a skill for each, and assembles them into a dependency-aware plan. Atomic skills are things you select. Composite ones are things you assemble.
A recurring-pattern skill is wide because it is generic, and length has little to do with it. Can agents learn reusable sub-task routines from past experience? shows how these arise. Agents pull routines out of past experience at a finer grain than whole tasks. They replace example-specific details, such as the particular site or item, with placeholders. They then stack small routines into bigger ones. The payoff grows with reach: gains of 24.6% on Mind2Web and 51.1% on WebArena get larger as the new tasks look less like the training tasks. Can a separate trained curator improve skill libraries better than frozen agents? points to the widest tier. A trained curator pushes a skill library away from verbose generic additions and toward actionable execution logic and cross-task meta-strategies, which are skills about how to approach a whole family of tasks.
Broader scope makes the skill harder to size and use correctly. What blocks skill retrieval in task decomposition? finds that standard LLM decomposition recovers only 34% of the right steps, and that this decomposition granularity gates retrieval more than the skill library does. If the request is cut at the wrong size, the matching skill is never found. Do skills teach procedures or inject missing facts? adds that skills mostly steady an agent's actions (65.7% of cases) and rarely supply missing facts (4.5%). They fail when retrieved wrongly, invoked out of context, or followed too rigidly. A multi-step script has more places to hit those failures than a one-step operation does. Do frontier LLMs silently corrupt documents in long workflows? shows the same compounding in long workflows generally: even top models degraded documents by about 25% over long relay chains, with errors that went unnoticed in spot checks.
The design response the corpus favors is to keep the composite structure in the scaffold and keep each model-facing piece narrow. Can algorithms control LLM reasoning better than LLMs alone? wraps LLM calls in an explicit algorithm that owns control flow and shows each call only its step-relevant context. Why do protocol-based tool integrations fail in production workflows? reports a similar fix: explicit direct function calls and one tool per agent restored determinism. Workflow-scale scope lives in the orchestration, and each atomic piece stays small enough to check. Where a skill is written also affects how well its scope fits. Does creating skills inside the agent loop eliminate mismatches? shows that skills created inside the running loop, with the exact task context and immediate feedback, reach 87.94% accuracy and transfer to other agents with little loss.
Sources 9 notes
Real agent tasks demand composing multiple skills rather than selecting one. The routing problem becomes decompose-retrieve-compose: break queries into atomic sub-tasks, retrieve skills per sub-task, and assemble them into dependency-aware plans.
Agent Workflow Memory induces sub-task routines at finer granularity than full tasks, abstracts example-specific values, and compounds them hierarchically. This produces 24.6% relative gain on Mind2Web and 51.1% on WebArena, with larger gains as train-test gaps widen.
SkillOS shows that separating a trainable curator from a frozen executor, grouped by task streams, causes skill repositories to shift from generic verbose additions toward actionable execution logic and cross-task meta-strategies. The trained curator generalizes across different executor backbones and domains.
Standard LLM decomposition reaches only 34% step-level recall, gating retrieval success. Correcting step count recovers 75% of gains in iterative methods, shifting the bottleneck to representation-level reranking rather than vocabulary alignment.
Analysis of 8,135 trials shows procedural anchoring accounts for 65.7% of skill cases versus 4.5% for knowledge injection. Skills fail when retrieved incorrectly, invoked out of context, or followed too rigidly.
Show all 9 sources
Even the strongest models (Gemini 3.1 Pro, Claude 4.6 Opus, GPT 5.4) degrade documents by ~25% over long relay workflows across 52 domains. Degradation decelerates but never plateaus, and errors compound silently, remaining undetected in spot-checked outputs.
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
MCP integration caused non-deterministic failures through ambiguous tool selection and parameter inference. Replacing it with explicit direct function calls and single-tool-per-agent design restored determinism. A 306-practitioner survey confirms 85% of production teams build custom agents, forgoing frameworks.
MUSE-Autoskill demonstrates that invoking skill creation from within the agent's reasoning loop grounds new skills in exact task context, immediate feedback, and runtime validation. In-loop skills reach 87.94% task accuracy and transfer to other agents with minimal loss, eliminating the situated context problem of offline authoring.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Compositional Skill Routing for LLM Agents: Decompose, Retrieve, and Compose
- Demystifying Agent Skills: Why They Work-Until They Don't
- RESOURCE2SKILL: Distilling Executable Agent Skills from Human-Created Multimodal Resources
- MUSE-Autoskill: Self-Evolving Agents via Skill Creation, Memory, Management, and Evaluation
- SkillOS: Learning Skill Curation for Self-Evolving Agents
- LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents
- ColluSkill: Adversarial Cross-Skill Composition for Evading Agent Skill Scanners
- Why Do Multi-agent LLM Systems Fail?