INQUIRING LINE

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

How should agents route across thousands of skills?

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.

Can agents learn reusable sub-task routines from past experience?

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.

Can a separate trained curator improve skill libraries better than frozen agents?

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.

What blocks skill retrieval in task decomposition?

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.

Do skills teach procedures or inject missing facts?

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
Do frontier LLMs silently corrupt documents in long workflows?

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.

Can algorithms control LLM reasoning better than LLMs alone?

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.

Why do protocol-based tool integrations fail in production workflows?

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.

Does creating skills inside the agent loop eliminate mismatches?

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.