New to ShortSpan? We distil the AI-security research that matters into practitioner takeaways — edited by Ben Williams (NCC Group).Get the weekly email
// Analysis
TRUSS probes agent skills with controlled execution
Published: Wed, 19 Aug 2026 • By Elise Veyron
Agents
TRUSS is an evidence‑guided framework that generates and repairs agent skills by combining static checks with supervised, sandboxed execution. It catches runtime behaviours that artifact inspection misses, links failures to specific skill content, and hardens them iteratively. In tests, it detected vulnerabilities with 100% precision and recall and cut attack success rates after repair.
Agent skills are reusable natural language procedures bundled with executable resources that let a Large Language Model (LLM) agent act beyond chat. Useful, but risky: you cannot tell from the package or the final task result which system calls, network touches, or file writes the skill will actually trigger.
How the attacks hide
The paper focuses on multi‑step, state‑dependent behaviours that look harmless until the agent composes tools and context. Think download‑and‑execute chains that only materialise after a previous step sets a flag, or a conditional branch that runs unauthorised commands when a specific API returns a value. Network calls can leak data as part of a “normal” workflow. None of this is obvious if you only read the skill text or score the end result. Static checks miss the choreography.
What TRUSS actually checks
TRUSS builds a loop: generate a complete skill, inspect it, then run it under supervision. The static gate verifies functional claims it can discharge and evaluates the artifact against nine predefined safety properties. Candidates that pass are loaded by a shadow agent inside a Controllable Execution Environment where brokered tools enforce policy and every action is recorded as a provenance‑preserving execution trace. When something fails, TRUSS links the failure back to the exact skill content and refines it, then repeats.
The numbers matter. On 168 SkillInject artifacts, TRUSS reached 100.00% precision and recall for vulnerability detection. On 155 SkillSafetyBench cases, repairing skills cut attack success from 38.71% to 19.35% with GPT 5.5 and from 46.45% to 29.68% with GPT 5.4, with zero attack regression. For 187 tasks in SkillGenBench, adding TRUSS‑generated skills lifted task effectiveness from 17.11% to 52.94% and raised the benchmark Security rate from 50.80% to 100.00%.
Two operational wrinkles show up. First, executor choice matters: repaired skills preserved more safe completions under GPT 5.5 than GPT 5.4, so your runtime model affects outcomes. Second, scenario coverage limits what can be certified. TRUSS can only assert safety for what it observes inside its supervised runs. Behaviours outside those scenarios remain a risk surface.
For defenders, the pitch is simple: execution evidence beats artifact inspection. The controlled environment, policy‑brokered tools, and provenance traces reveal the real behaviour path and give you something auditable to hold. The open questions are also clear: how much scenario coverage is enough, which safety properties deserve to be standard, and how to make checks consistent across different executors.
Additional analysis of the original ArXiv paper
📋Original Paper Title and Abstract
TRUSS: Towards Task-Reliable and User-Safe Automated Agent Skill Generation
Authors: Zhibo Zhang, Zhen Ouyang, Ling Shi, and Kailong Wang
Agent Skills package reusable natural language procedures with executable resources, enabling software agents to acquire task specific capabilities without model adaptation. Automatically generating such Skills can improve task performance, yet evaluating a candidate solely from its artifact or final task outcome leaves unresolved which actions the equipped agent will perform and which side effects those actions will produce. We present TRUSS, an evidence guided framework for generating functionally effective and safety reliable Agent Skills. TRUSS first inspects functional claims against source and domain evidence while evaluating the complete artifact under nine predefined safety properties. Candidates admitted by this static gate are loaded by a shadow agent inside a Controllable Execution Environment, where brokered tools expose requested actions to policy enforcement and record their results as provenance preserving execution traces. Functional failures and property violations are linked back to the responsible Skill content and used to guide iterative refinement. We evaluate TRUSS on 168 SkillInject artifacts, 155 SkillSafetyBench cases, and all 187 tasks in SkillGenBench. TRUSS achieves 100.00\% precision and recall in vulnerability detection. Repair reduces attack success from 38.71\% to 19.35\% with GPT 5.5 and from 46.45\% to 29.68\% with GPT 5.4, with zero attack regression. For Skill generation, TRUSS raises task effectiveness from 17.11\% without Skills to 52.94\%, while increasing the benchmark Security rate from 50.80\% to 100.00\%. These results show that execution evidence can expose behavioral failures missed by artifact inspection and can guide Skill generation toward jointly verified functional and safety outcomes.
🔍ShortSpan Analysis of the Paper
Problem
The paper studies automated generation of Agent Skills, which are reusable natural language procedures with executable resources that extend LLM-based agents without changing model parameters. Automatically generating Skills can improve task performance but risks introducing unsafe runtime behaviours that static inspection of the artifact or final task outcomes can miss. The work addresses the dual requirements of Functional Effectiveness (measurable task improvement) and Safety Reliability (absence of security‑relevant or unauthorised actions during execution).
Approach
TRUSS is an iterative, evidence‑guided framework that combines static artifact checks with supervised execution inside a Controllable Execution Environment (CEE). Generation produces a complete Skill package (instructions plus executable resources). A Checker performs static inspection to discharge determinable functional claims and to establish which safety properties require runtime observation. Admitted candidates are executed by a shadow agent in the CEE where brokered tools, an intermediate breaker and a disposable sandbox enforce policies and return provenance‑preserving execution traces. Functional and safety observations are recorded in a Function and Safety Record; failures are returned to a Refiner that edits the Skill and restarts the loop. TRUSS evaluates Skills under task‑conditioned and task‑agnostic regimes and operationalises nine predefined safety properties covering the execution path through which a Skill can influence an agent or its environment.
Key Findings
Static inspection alone misses a substantial set of runtime vulnerabilities; adding execution evidence improves detection and repair signals.
Vulnerability detection reached 100.00% precision and recall on 168 SkillInject artifacts (84 matched clean/injected pairs), outperforming LLM-only and static checks.
Repairing Skills reduced attack success rate on 155 SkillSafetyBench cases from 38.71% to 19.35% with GPT 5.5 and from 46.45% to 29.68% with GPT 5.4, with zero attack regression.
For Skill generation across 187 SkillGenBench tasks, TRUSS increased task effectiveness from 17.11% (no Skills) to 52.94% and raised benchmark Security from 50.80% to 100.00%, converting unsafe executions into certified safe ones.
Model behaviour materially affects outcomes: repaired Skills preserved more safe completions under GPT 5.5 than GPT 5.4, showing executor sensitivity.
Limitations
Results depend on the scope of evaluated scenarios and the behaviour of the executor model; TRUSS is sensitive to scenario coverage and executor differences. The framework certifies safety only under the scenarios and observers used during supervised execution; residual unsafe behaviours may remain outside those scenarios. Evaluations used benchmark suites and specific model configurations, so generalisation beyond those setups is not proven.
Implications
Offensive implications arise from the ability to hide multi‑step, state‑dependent attacks inside Skill packages that appear benign under artifact inspection but induce harmful actions at runtime. Attackers can embed download‑and‑execute chains, unauthorised system commands, network interactions or data‑exfiltration flows that only materialise after composed actions. The reported sensitivity to scenario coverage and executor behaviour implies attackers could evade TRUSS by crafting behaviours outside the CEE scenarios or by exploiting quirks of target models, making targeted evasion feasible unless execution coverage and observers are broadened.
- It tackles adaptive attackers that iteratively rewrite AI agent skills to evade audits and still cause harm, showing a realistic and evolving threat...
- It reveals a new attack surface: safety failures can be triggered not just by user prompts, but via skill materials and local artifacts that guide a...
- It provides a dynamic benchmark to test how well LLM agents handle third-party skills without falling for malicious runtime behavior, addressing a r...
- Introduces Runtime Skill Audit (RSA): a dynamic method that watches how an agent actually behaves in targeted runtime conditions, not just what it s...
- It shows that security issues can emerge only when multiple skills are combined in an agent’s workflow, not when each skill is tested alone.
- The S...
- It introduces dynamic safety testing using adaptive “honey worlds” that simulate decoy environments to coax an AI agent into revealing hidden or con...
- Introduces a new threat: backdoors embedded in the building blocks of AI agents (the skills), not just in models or data.
- Attacker hides malicious...
- It addresses security of untrusted AI agent skills packaged as reusable units, aiming to catch malicious or risky content across multiple files rath...
- It exposes a new attack surface where agent skills combine natural-language specs with executable code, enabling covert exfiltration even when the c...
- It tackles the security risk of loading external “skills” or plugins into LLM runtimes by treating them as untrusted until verified, addressing supp...
Get the weekly digest
The few AI-security papers that matter, with the practitioner takeaway. No spam.