From Skill Text to Skill Structure: The Scheduling-Structural-Logical Representation for Agent Skills

1. Problem Statement

Large Language Model (LLM) agents increasingly rely on reusable skills (bundles of instructions, control flow, constraints, and tool calls). However, current skill artifacts are predominantly represented as text-heavy documents (e.g., SKILL.md, READMEs, or JSON records with natural language fields).

This text-dominant approach creates a representational bottleneck:

• Entanglement: Critical machine-usable signals (invocation interfaces, execution structure, and resource-side effects) are entangled within unstructured natural language.
• Downstream Challenges:
  • Skill Discovery: Retrieving the correct skill from a large registry is difficult because sparse metadata cannot capture implementation-level cues or structural dependencies hidden in long texts.
  • Risk Assessment: Identifying security risks (e.g., data exfiltration, privilege escalation) is error-prone because reviewers must infer operational boundaries and side effects from noisy, unstructured prose.
• Gap: There is a lack of a standardized, source-grounded intermediate representation that disentangles these distinct properties for machine consumption.

2. Methodology: The SSL Representation

The authors propose the Scheduling-Structural-Logical (SSL) representation, the first structured schema designed specifically for agent skill artifacts. It is grounded in classical linguistic knowledge representation theories (Schank & Abelson):

1. Memory Organization Packets (MOPs): For goal-oriented context.
2. Script Theory: For ordered execution phases.
3. Conceptual Dependency: For primitive action structures.

The SSL schema maps an unstructured skill document into a typed, three-layer JSON graph:

A. Scheduling Layer (Skill-Level Interface)

• Purpose: Acts as the invocation-level capability unit.
• Content: Captures the skill's goal, intent signature, tags, expected inputs/outputs, dependencies, and high-level control flow features (e.g., branching, loops).
• Function: Provides a stable record for routing and selection without needing to parse the full execution graph.

B. Structural Layer (Scene-Level Execution Phases)

• Purpose: Represents the skill as a sequence of coherent execution phases (scenes).
• Content: Nodes are scenes (e.g., PREPARE, ACQUIRE, REASON, ACT, VERIFY, RECOVER, FINALIZE). Edges represent transitions with entry/exit conditions.
• Function: Makes the workflow topology visible and inspectable before diving into atomic actions.

C. Logical Layer (Atomic Actions & Resource Evidence)

• Purpose: Decomposes scenes into source-grounded atomic actions.
• Content: Nodes are logic steps defined by primitive act_type (e.g., READ, WRITE, CALL_TOOL, TRANSFER), actors, instruments, and crucially, resource scopes (e.g., LOCAL_FS, NETWORK, CREDENTIALS) and effects.
• Function: Provides explicit evidence of what resources are accessed and how, enabling precise risk analysis.

D. Implementation: The LLM Normalizer

The authors instantiate SSL using an LLM-based normalizer that converts existing SKILL.md files into the SSL schema.

• Grounding Policy: The normalizer acts as a semantic extractor, not a summarizer. It strictly populates fields only with evidence present in the source document.
• Validation: It enforces strict schema constraints, unique identifiers, and closed vocabularies. If evidence is missing, fields are left empty/null rather than hallucinated.
• Pipeline: A four-pass process: (1) Extract scheduling record, (2) Decompose into scenes, (3) Expand to logic steps, (4) Verify structural integrity.

3. Key Contributions

1. SSL Schema: A novel, three-layer structured representation that disentangles scheduling signals, execution structure, and logical resource evidence.
2. LLM Normalizer: A tool to convert unstructured skill documentation into the SSL format with high fidelity and grounding.
3. Benchmarks & Datasets:
   • A corpus of 6,184 public agent skills.
   • Skill Discovery Benchmark: 403 task-grounded queries for retrieval evaluation.
   • Risk Assessment Benchmark: 500 skills with six-dimensional ordinal risk labels (Data Exfiltration, Destructive Behavior, Privilege Escalation, Covert Execution, Resource Abuse, Credential Access).
4. Empirical Validation: Demonstrated that structured representations significantly outperform text-only baselines in both discovery and security tasks.

4. Experimental Results

A. Skill Discovery (Retrieval)

• Task: Match user queries to the correct skill in a registry of 6,184 candidates.
• Metric: Mean Reciprocal Rank (MRR).
• Results:
  • Baseline (Description Only): MRR = 0.573.
  • Baseline (Full SKILL.md): MRR = 0.602.
  • Best SSL Variant (Desc + SSL-Rich): MRR = 0.707.
• Insight: Rich SSL-derived fields (scene types, explicit dependencies, interface signatures) provide stronger retrieval signals than raw text or shallow metadata. Concise structured summaries outperform embedding long documents.

B. Risk Assessment

• Task: An LLM judge evaluates skills for six risk dimensions on a 1–5 scale.
• Metric: Macro F1 (for binary risk detection) and Mean Absolute Error (MAE).
• Results:
  • Baseline (Full SKILL.md): Macro F1 = 0.744.
  • Combined View (SKILL.md + SSL): Macro F1 = 0.787.
  • Full SSL Alone: Macro F1 = 0.775.
• Insight: Structured evidence significantly improves the detection of risks tied to explicit operations (e.g., credential access, destructive behavior). However, for complex judgments requiring narrative context (e.g., privilege escalation), the combination of source text and SSL yields the best results, suggesting SSL should augment, not replace, the source document.

5. Significance and Implications

• Evidence Interface: SSL serves as a "source-adjacent" evidence interface. It makes different types of evidence (interface, workflow, resource) explicitly available for downstream systems to select based on task needs.
• Operational Actionability: By separating invocation cues from execution logic, SSL enables more robust skill management, including better routing, policy checking, and human review.
• Future Direction: The paper positions SSL not as a finished standard but as a practical step toward inspectable, reusable, and operationally actionable skill representations. Future work may involve linking SSL graphs into repository-level knowledge graphs or using them for runtime agent execution checkpoints.
• Limitations: The current approach relies on static artifacts (missing dynamic runtime traces) and depends on LLM normalization fidelity. It is most effective for skills where resource access and control flow are explicitly documented.

In conclusion, the paper argues that moving from "text-heavy" to "structure-grounded" representations is essential for scaling agent ecosystems, offering a concrete path to improve both the discoverability and safety of LLM agent skills.