Imagine a world where software isn't just lines of code, but a living, breathing ecosystem of "skills." Think of these skills like digital Swiss Army knives or magical recipe cards that tell a super-smart robot (an AI agent) exactly how to do a job. These aren't just simple instructions; they are mixed-media packages containing written guides, actual computer code, lists of tools to use, and step-by-step workflows. As these skills become popular, people start sharing them in online marketplaces, just like apps on a phone store. But here's the tricky part: because these skills are so complex, it's hard to tell if someone just copied a recipe and changed the font, or if they actually stole the secret sauce—the specific code, the unique way the steps are ordered, or the clever tricks used to make it work. This is a big deal because if bad or broken skills get copied around, the whole ecosystem can get messy or dangerous. Scientists have long tried to spot copied computer code, but those old tools are like looking for a specific word in a book; they miss the story if the author rewrites the sentences or changes the chapter order.

Enter SkillTrace, a new detective tool designed to solve this mystery. Instead of just comparing the whole "package" to see if they look alike, SkillTrace acts like a forensic investigator who looks at three different layers of evidence: the words (the written instructions), the code (the actual scripts), and the operation (the invisible flow of how the skill actually works). The researchers found that even if a thief rewrites the instructions and changes the code, they often can't help but keep the same "dance steps" or operational flow because that's what makes the skill function. By building a special map called a "Skill Operational Graph" to track these dance steps, SkillTrace can catch reuse that other tools miss. In tests with hundreds of skills, this new method was much better at spotting these hidden copies, catching about 90% of the real reuse cases while keeping false alarms low. It's like having a detective who doesn't just check if two houses look the same from the outside, but can tell if they share the same unique plumbing layout, even if the paint colors and front doors are completely different.

The Story of the Digital Recipe Thief

Imagine you are a chef who has invented a fantastic new way to bake a cake. You write down a detailed recipe (the Expression), you list the specific tools and ingredients you use (the Implementation), and you describe the exact order of operations: "preheat, mix, fold, bake, cool" (the Operation). Now, imagine a rival chef wants to steal your success. They might try to copy your recipe word-for-word, or they might rewrite the whole thing in a different language but keep your exact list of tools. Or, they might try to be sneaky: they change the recipe's title, rewrite the instructions in their own voice, and even swap out your mixing bowl for a different brand. But here's the catch: to make the cake rise and taste right, they have to keep your specific sequence of steps. They can't just "mix then bake" if your recipe requires "fold then chill."

This is exactly the problem the SkillTrace paper tackles, but with AI agents instead of bakers. In the world of AI, "skills" are these complex packages that tell an AI how to do things. The authors realized that old tools for finding copied software were like looking at the cover of a cookbook. If the rival chef changed the cover art and the title, the old tools would say, "No match!" even if the chef stole the entire recipe inside.

The Three-Layer Detective Work

SkillTrace is different because it doesn't just look at the whole book; it breaks the skill down into three distinct "traces" or layers of evidence, much like a detective examining a crime scene for fingerprints, DNA, and footprints.

1. The Expression Trace (The Words): This is the written part of the skill—the instructions, the descriptions, and the examples. If a thief copies your text, this layer lights up. But if they rewrite the text to sound different, this layer goes dark.
2. The Implementation Trace (The Code): This is the actual computer code, scripts, and commands. If the thief copies your code snippets, this layer catches them. But if they rewrite the code in a different language or delete it entirely, this layer goes silent.
3. The Operational Trace (The Dance Steps): This is the paper's big innovation. It looks at how the skill works. It builds a map called a Skill Operational Graph (SOG). This map doesn't care about the words or the specific code names; it cares about the flow. It tracks:
   • Activation: How does the skill start?
   • Procedure: What is the order of steps?
   • Resource Flow: What tools and data move through the process?

The authors discovered that even if a thief rewrites the words and changes the code, they often can't change the "dance steps." If a skill is designed to read a PDF, extract data, and then email it, a thief might change the file names and the programming language, but they still have to follow that same three-step flow. The Operational Trace catches this invisible structure.

The Magic Graph and the "One-LLM" Trick

To build this map, the researchers use a clever trick. When a new skill enters the system, they use a powerful AI (an LLM) just once to read the messy, mixed-up skill package and turn it into a clean, structured graph. This is like hiring a translator once to turn a chaotic diary into a clear flowchart. Once that graph is saved, the system never needs the expensive AI again.

When it's time to check if a new skill is a copy, the system just compares the saved graphs. It's fast, cheap, and doesn't need to call the AI again. It compares the "dance steps" of the original skill against the "dance steps" of the new one. If the steps match, even if the music and the costumes are different, the system flags it.

What They Found: Catching the Sneaky Copycats

The researchers tested their tool, SkillTrace, on a massive dataset. They created a benchmark called SkillTrace-Bench with 820 examples of skills that were definitely reused (positives) and 751 examples of skills that were just similar by chance (negatives).

The results were impressive. SkillTrace achieved a score of 0.938 (AUROC) and an F1 score of 0.898. To put that in plain English, it means the tool was extremely good at spotting real reuse while rarely crying wolf about innocent similarities.

But the real magic was in how it found them. The paper showed that different types of "thefts" leave different footprints:

• The "Repackager": Someone who just changes the title and folder names. Old tools catch these easily, and so does SkillTrace.
• The "Rewriter": Someone who uses an AI to completely rewrite the code and text. Old tools often miss these because the words and code look totally different. But SkillTrace's Operational Trace caught them because the "dance steps" (the procedure) remained the same.
• The "Partial Thief": Someone who steals just the code but writes new instructions, or steals the instructions but writes new code. SkillTrace is smart enough to say, "Hey, the words are different, but the code is a match!" or "The code is new, but the flow is identical!"

In a real-world test with 36,446 skills from public marketplaces, SkillTrace found thousands of potential reuse cases that the old "whole-package" tools missed. It found that while big, obvious copies are common, there is a huge amount of "partial" reuse where people steal specific parts of a skill without copying the whole thing.

Why This Matters

The paper argues that we need this kind of detailed auditing because the AI skill ecosystem is growing fast. If we can't tell who copied whom, we can't fix bugs that spread through copies, we can't protect creators' work, and we can't keep the marketplace fair.

SkillTrace doesn't make legal judgments—it doesn't say "You are guilty of theft." Instead, it acts as a high-tech triage system. It says, "Look here, this skill shares the exact same 'dance steps' as that one, even though the clothes are different. A human should take a closer look." By separating the evidence into words, code, and operations, it gives humans the specific clues they need to make the final call.

In the end, the authors show that by looking at the structure of how a skill works, rather than just its surface appearance, we can finally see the invisible threads of reuse that hold the AI world together. It's a reminder that while you can change the paint on a car, you can't easily change the engine's blueprint without rebuilding the whole thing. SkillTrace is the tool that finally lets us see that blueprint.