The Decomposition Is the Fingerprint: Per-Component Identity for Agent Skills
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: I'm Nadia.
Elias: And I'm Elias, here with Priya.
Nadia: We're looking at the paper: "The Decomposition Is the Fingerprint".
Elias: Here's the gist of the paper. AI agents increasingly acquire and execute skills at runtime: bundles of prompt instructions, executable code, and tool declarations fetched from marketplaces and other agents The central claim is that keeping the fingerprint as a per-component triple, rather than a single score, is what makes it useful: the triple recovers skill-family identity through paraphrase, renaming, refactoring, and controlled code translation recovered via a shared component (an independent multilingual reimplementation is not), and it localizes which component carries the reuse A per-component embed-then-SimHash fingerprint provides a 120-byte skill-family identity that survives common rewrites and localizes which component carries the reuse, turning similarity into a registry primitive What is the core problem addressed Large language model agents have moved from answering questions to acquiring and executing skills: reusable bundles of prompt instructions, executable code, and tool or API declarations that an agent loads at runtime to extend what it can do Platform and governance teams face an identity problem before they face anything else: they cannot deduplicate, search, version, attribute, or audit a corpus of skills they cannot reliably tell apart Cryptographic hashing fails (a), (c), and (d) by design No prior method satisfies all four properties together How the training signal is built The fingerprint is defined in three steps: decomposing a skill into its components, embedding and projecting each component to bits independently, and comparing two fingerprints component by component Each component is treated as a textual artifact drawn from a fixed vocabulary, such as the natural-language prompt or the code that implements the skill The embedding step uses a learned text encoder E(·) → R d (here d = 768), which maps paraphrases, renamings, and refactorings of the same component to nearby vectors Each embedding is then projected to bits with a multi-bank SimHash The resulting fingerprint is a concatenation of these per-component codes, yielding a fixed 120-byte signature regardless of skill size Where the gains come from The decomposition into components allows for component-wise comparison using Hamming distance, which yields a per-component similarity triple Code is identified as the strongest identity signal (AUC 0.997), tools as the cleanest (1.000), and prompt as the weakest (0.959) Relationship classification is automatic, yielding six relationship types directly from the triple The fingerprint recovers 45/50 adversarial rewrites, including cross-language translation, where a lexical baseline recovers 5/50 How identity and safety are separated The fingerprint provides structural identity, which is complementary to behavioral integrity On a 906-skill injection benchmark, the fingerprint flags injected skills as tampered copies of a known base and localizes the change Recognition is not trust; it remains an identity signal complementary to behavioral verification rather than a safety verdict The two axes compose, and we show where the identity axis ends How the system is deployed The fingerprint becomes a registry with per-component indexing, calibration, and a CycloneDX skill bill of materials (SkillBOM) Indexing allows for constant-size, constant-time-per-comparison property at registry scale Calibration maps raw scores to a z-score using an empirical distribution of negative pairs so that 0.5 denotes the random baseline The SkillBOM records both exact integrity (the hash) and lineage (the fuzzy per-component fingerprint) for every skill Where the gains come from The triple classifies relationships directly, allowing classification of clones, reimplementations, and tool swaps based on high and low per-component similarities The same per-component distances scale from pairwise relationships to corpus-level structure, grouping skills into families (sets of skills that implement the same capability) Novelty is detected rather than mis-merged by flagging skills that match no family or exceed the 95th-percentile intra-family distance The system's usefulness lies in its ability to provide a portable "SkillBOM" for a skill registry Where the gains come from The fingerprint is locality-sensitive, not collision-resistant, meaning an adversary who knows the encoder and projection planes can move a component’s embedding to evade a match The useful score range is narrow, with the positive background cosine of unrelated components flooring scores near 0.65 This floor is absorbed by calibration against the empirical negative distribution, making raw scores uninterpretable as percentages The fingerprint is encoder-agnostic, meaning a newer, wider encoder buys ≈ 0.
Paper summary: Nadia: So, this paper is about how AI agents get skills now, like loading bundles of instructions and code at runtime. The core problem they're tackling is that platform teams can't reliably tell if two skills are the same or different because standard cryptographic hashing breaks when you change even a tiny part of the skill.
Elias: Exactly. Cryptographic hashing has this avalanche effect, which means a single character edit scrambles the digest completely, so it can't measure similarity at all, especially when we need to find similarities between skills that have been paraphrased or refactored.
Priya: And they’re proposing something new—a per-component triple fingerprint instead of a single score. The central claim is that keeping the components separate—the prompt, the code, and the tools—is what allows you to recover skill family identity through things like paraphrasing or renaming.
Nadia: So, it's about making sure you know *which* part of a skill is doing what it’s supposed to be doing instead of just getting one big score for the whole thing. How does this decomposition actually work in practice?
Elias: Well, they define the fingerprint in three steps. First, you decompose a skill into its parts—like text prompts, executable code, and tool declarations. Then, each component gets embedded independently using a learned text encoder that maps paraphrases to nearby vectors.
Priya: And then those embeddings are projected onto bits using a multi-bank SimHash projection. The final fingerprint is just the concatenation of these per-component codes, resulting in this fixed one hundred twenty byte signature regardless of how big the skill gets.
Nadia: That fixed size sounds useful for registry work, but what’s the actual comparison mechanism they use? How do you compare two different skills using this triple?
Elias: They compare them component by component using Hamming distance. For example, they look at how similar the prompt part is between the two skills, then the code part separately, and so on. The triple itself isn't collapsed into a single score inside the fingerprint; it stays as three separate codes.
Paper summary: Priya: That per-component comparison is key because it allows them to localize which component carries the reuse. They find that code has the strongest identity signal—AUC of zero point nine nine seven—followed by tools at one point zero zero zero, and prompts are the weakest at zero point nine five nine.
Nadia: So, if you were looking at a similarity between two skills, this method tells you not just how similar they are overall, but exactly which piece of the skill is causing that similarity. What does this mean for checking if one agent skill is just a slightly modified version of another?
Elias: It recovers forty five percent of adversarial rewrites, including cross-language translations where their lexical baseline recovers fifty percent. They found that this triple structure helps them classify relationships directly, allowing them to spot clones or reimplementations based on those high and low per-component similarities.
Priya: But they’re also careful about what they claim. They mention that the fingerprint provides structural identity, which is complementary to behavioral integrity. It flags injected skills as tampered copies of a known base, but they stress that this isn't a safety verdict; it's an identity signal used alongside other checks for behavior.
Nadia: That makes sense for governance because you need to track lineage without letting the system make final decisions about safety on its own. So, how do you actually deploy this thing in a real system? What’s the structure they use?
Elias: They turn it into a registry with per-component indexing and calibration. They use something called a CycloneDX skill bill of materials, or SkillBOM, to record both the exact integrity hash and this fuzzy per-component fingerprint for every skill.
Priya: The calibration part is interesting because they map raw similarity scores to a z-score using an empirical distribution of negative pairs, so that a score of zero point five means it’s just like random noise. This makes the raw numbers much more interpretable in a registry context.
Nadia: That sounds like it solves the problem of raw scores being uninterpretable percentages. So, what is the big picture implication for how we manage these skills moving forward?
Paper summary: Elias: The paper argues that this per-component identity allows you to group skills into families—sets of skills that implement the same capability. Novelty is detected by flagging a skill if it matches no family or exceeds ninety five percent intra-family distance. It gives you a portable SkillBOM for any skill registry.
Priya: The limitation they state is that the fingerprint is locality-sensitive, not collision-resistant. This means if someone knows the exact encoder and projection planes, they can potentially move a component's embedding to evade a match with minimal change.
Nadia: So the system isn't perfectly secure against an adversary who understands its internals? How do they handle that kind of risk in their design?
Elias: They say that the useful score range is narrow, and the positive background cosine for unrelated components floors scores near zero point six five. That floor is absorbed by calibration against the empirical negative distribution, which makes raw scores uninterpretable as percentages.
Priya: And they also note that the fingerprint is encoder-agnostic; meaning if you use a newer, wider text encoder, it only buys you about zero point one in terms of improvement to the signature quality itself.
Nadia: So to summarize this paper, "The Decomposition Is the Fingerprint: Per-Component Identity for Agent Skills" suggests that instead of hashing skills as one blob and failing every time they change, you should hash each part separately and compare those parts. The main gain is being able to track lineage and understand exactly which piece of a skill is reused.
Elias: It moves the identity problem from a single score to a triple structure that lets you recover family identity through comparison across components, even after paraphrasing or refactoring. It's about localizing reuse rather than just giving you one number for the whole thing.
Priya: The implication is that this approach provides a way for large systems to manage skill catalogs at scale by offering a calibrated, component-aware verdict instead of relying on flawed cryptographic hashing for similarity measurement.
Conclusion: Nadia: So, we've been looking at how AI agents get skills now, and this paper is called "The Decomposition Is the Fingerprint: Per-Component Identity for Agent Skills."
Elias: Right. It’s about moving away from just one big score for a skill and breaking it down into its pieces.
Nadia: Exactly. They argue that keeping each piece—the prompt, the code, the tools—as a separate component in a triple makes it useful.
Elias: That triple structure lets you recover skill identity even when things are paraphrased or renamed, because you compare those parts individually.
Priya: I’m interested in what they actually show with their numbers. How does this work practically for checking if one skill is just a modified version of another?
Nadia: Well, they found that comparing the code component gives them the strongest signal, like zero point nine nine seven on the similarity score.
Elias: And tools are next at one point zero zero zero, but prompts are weaker at zero point nine five nine. That shows which part of the skill matters most for identifying a family of skills.
Priya: But you gotta ask what those numbers mean before you trust them. What’s the real deal with that similarity score?
Nadia: They use a calibration step where they map raw scores to something called a z-score using an empirical distribution of negative pairs. So zero point five means it's just like random noise, not a definitive match.
Elias: That makes the number much more usable for registry work, which is what they are aiming for with this SkillBOM idea.
Nadia: It turns similarity into something you can actually use to categorize and audit skills at a large scale.
Elias: It’s about providing a portable skill bill of materials that tracks both the exact integrity and this fuzzier per-component fingerprint for every skill.
Priya: So it's not just about saying "this is similar," it's about telling you *where* the similarity comes from within the skill structure.
Nadia: Exactly. It’s a structural way to see things, which helps separate what’s structurally the same from what might be behaviorally different.
Elias: The authors also point out that this fingerprint is not perfectly collision-resistant if someone knows their secret encoder setup. That's a limitation you have to watch out for.
Priya: So it’s a tool for organization and auditing, but it doesn’t guarantee absolute security against someone who really knows how the system works?
Nadia: Right. It’s about using identity as a way to build that safety layer, but it isn't the final word on behavior.
Elias: This whole thing suggests we need to start thinking about skills not just as one blob of text or code, but as interconnected pieces.
Palo Alto Networks
cs.CR, cs.CL, cs.LG
Submitted: 2026-06-30
Updated: 2026-11-12
Code: https://github.com/openclaw/openclaw
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 88/100
The gist: AI agents increasingly acquire and execute skills at runtime: bundles of prompt instructions, executable code…
Key concepts
- Per-Component Triple
- Instead of one score for a whole skill, this uses three scores—one for each component (prompt, code, tool). This triple recovers the true identity of a skill family by allowing comparison through paraphrasing or renaming.
- SimHash Fingerprint
- Each component is embedded into bits using SimHash. This creates a fixed-size 120-byte signature that captures the essence of the component, making it robust against common textual changes like rephrasing.
- SkillBOM Indexing
- This system uses the fingerprint to create a registry where skills are indexed by their components. It allows for constant-size comparisons and tracks both exact integrity (the hash) and fuzzy lineage (the component fingerprint) for every skill.
Terminology
Summary
AI agents increasingly acquire and execute skills at runtime: bundles of prompt instructions, executable code, and tool declarations fetched from marketplaces and other agents The central claim is that keeping the fingerprint as a per-component triple, rather than a single score, is what makes it useful: the triple recovers skill-family identity through paraphrase, renaming, refactoring, and controlled code translation recovered via a shared component (an independent multilingual reimplementation is not), and it localizes which component carries the reuse A per-component embed-then-SimHash fingerprint provides a 120-byte skill-family identity that survives common rewrites and localizes which component carries the reuse, turning similarity into a registry primitive
What is the core problem addressed
Large language model agents have moved from answering questions to acquiring and executing skills: reusable bundles of prompt instructions, executable code, and tool or API declarations that an agent loads at runtime to extend what it can do Platform and governance teams face an identity problem before they face anything else: they cannot deduplicate, search, version, attribute, or audit a corpus of skills they cannot reliably tell apart Cryptographic hashing fails (a), (c), and (d) by design No prior method satisfies all four properties together
How the training signal is built
The fingerprint is defined in three steps: decomposing a skill into its components, embedding and projecting each component to bits independently, and comparing two fingerprints component by component Each component is treated as a textual artifact drawn from a fixed vocabulary, such as the natural-language prompt or the code that implements the skill The embedding step uses a learned text encoder E(·) → R d (here d = 768), which maps paraphrases, renamings, and refactorings of the same component to nearby vectors Each embedding is then projected to bits with a multi-bank SimHash The resulting fingerprint is a concatenation of these per-component codes, yielding a fixed 120-byte signature regardless of skill size
Where the gains come from
The decomposition into components allows for component-wise comparison using Hamming distance, which yields a per-component similarity triple Code is identified as the strongest identity signal (AUC 0.997), tools as the cleanest (1. p. 1 Code is the strongest identity signal (AUC 0. 997) and tools the cleanest (1. 997) and tools the cleanest (1. 000), while prompt is weakest (0.Where the paper says it
Where the paper says it
How identity and safety are separated
The fingerprint provides structural identity, which is complementary to behavioral integrity On a 906-skill injection benchmark, the fingerprint flags injected skills as tampered copies of a known base and localizes the change Recognition is not trust; it remains an identity signal complementary to behavioral verification rather than a safety verdict The two axes compose, and we show where the identity axis ends
How the system is deployed
The fingerprint becomes a registry with per-component indexing, calibration, and a CycloneDX skill bill of materials (SkillBOM) Indexing allows for constant-size, constant-time-per-comparison property at registry scale Calibration maps raw scores to a z-score using an empirical distribution of negative pairs so that 0.5 denotes the random baseline The SkillBOM records both exact integrity (the hash) and lineage (the fuzzy per-component fingerprint) for every skill
The triple classifies relationships directly, allowing classification of clones, reimplementations, and tool swaps based on high and low per-component similarities The same per-component distances scale from pairwise relationships to corpus-level structure, grouping skills into families (sets of skills that implement the same capability) Novelty is detected rather than mis-merged by flagging skills that match no family or exceed the 95th-percentile intra-family distance The system's usefulness lies in its ability to provide a portable SkillBOM
for a skill registry
The fingerprint is locality-sensitive, not collision-resistant, meaning an adversary who knows the encoder and projection planes can move a component’s embedding to evade a match The useful score range is narrow, with the positive background cosine of unrelated components flooring scores near 0.65 This floor is absorbed by calibration against the empirical negative distribution, making raw scores uninterpretable as percentages The fingerprint is encoder-agnostic, meaning a newer, wider encoder buys ≈ 0. p. 4 0]
rather than [0, 1]. Neither effect is a defect, but together they make raw scores uninterpretable as
percentages, which is why the system calibrates against the empirical negative distribution before
exposing a score (Section 7).Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Improve skill deduplication by using a per-component triple to
recover skill-family identity through paraphrase, renaming, refactoring, and controlled code translation.
This allows for precise classification of relationships likerepurposing
(high code, low prompt) versusreimplementation
(high prompt, low code). -
Implement a registry that provides constant-size and O(1)-comparable skill identity by using a 120-byte fingerprint compared by Hamming distance. This allows for fast indexing and comparison of skills at registry scale without relying on cryptographic hashing or large vector embeddings.
-
Enhance skill search and discovery by enabling component-level nearest-neighbor queries, allowing a query to ask
which known skills are closest here?
per component code, prompt, or tools independently. -
Establish a portable and auditable artifact record by generating a CycloneDX SkillBOM that records the per-component fingerprint along with provenance blocks and cryptographic content hashes for every skill.
-
Improve safety verification by employing a two-axis model: structural identity (the fingerprint) to recognize
tampered copies of known base
while pairing it with behavioral verification to adjudicate whether the skill is safe, asidentity is not a safety verdict.
Abstract
AI agents increasingly acquire and execute skills at runtime: bundles of prompt instructions, executable code, and tool declarations fetched from marketplaces and other agents. Governing them needs a stable notion of skill identity, yet cryptographic hashing is engineered to destroy the very similarity we need, as a one-character edit scrambles the digest. We present a compact, locality-sensitive fingerprint that embeds each component of a skill and projects it to bits with a multi-bank SimHash, giving a fixed 120-byte signature compared in constant time by Hamming distance. Our central claim is that keeping the fingerprint as a per-component triple (prompt, code, tools), rather than a single score, is what makes it useful: the triple recovers skill-family identity through paraphrase, renaming, refactoring, and controlled code translation when another component remains shared, while independent multilingual reimplementation is not recovered; it also localizes which component carries the reuse. We claim lineage, not behavioral equivalence: identity supplies the structural axis of a registry and leaves safety to behavioral verification. The fingerprint reaches an area under the ROC curve (AUC) of 0.974 (95% CI [0.956, 0.994]) over 4,950 pairwise comparisons while using 77x fewer bits than the embedding it approximates, with ranking preserved in expectation and finite-bit concentration; the per-component split turns one number into relationship classification, families, novelty, and a portable "SkillBOM" for a skill registry. On a 906-skill injection benchmark the fingerprint recognizes injected skills as tampered copies of a known base and localizes the change, but recognition is not trust: it remains, by design, an identity signal complementary to behavioral verification rather than a safety verdict.
Sources
- AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents
- CodeBERT: A Pre-Trained Model for Programming and Natural Languages
- Datasheets for Datasets
- Not what you've signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection
- On Calibration of Modern Neural Networks
- GraphCodeBERT: Pre-training Code Representations with Data Flow
- UniXcoder: Unified Cross-Modal Pre-training for Code Representation
- Accelerating Large-Scale Inference with Anisotropic Vector Quantization
- CodeSearchNet Challenge: Evaluating the State of Semantic Code Search
- SkillJect: Effectively Automating Skill-Based Prompt Injection for Skill-Enabled Agents
- Billion-scale similarity search with GPUs
- On the Sentence Embeddings from Pre-trained Language Models
- SkillsBench: Benchmarking How Well Agent Skills Work Across Diverse Tasks
- AgentBench: Evaluating LLMs as Agents
- "Do Not Mention This to the User": Detecting and Understanding Malicious Agent Skills in the Wild
- Model Cards for Model Reporting
- MTEB: Massive Text Embedding Benchmark
- Scalable Fingerprinting of Large Language Models
- Gorilla: Large Language Model Connected with Massive APIs
- ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs
Related papers
- From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment
- Privacy Leakage from Recurrent State in LLM Inference
- Incrementally Verifiable Oracle Aided Computation
- Privilege and confidentiality in generative AI workflows
- BadMoE: Backdooring Mixture-of-Experts LLMs via Routing-Aware Triggers and Task-Underutilized Experts
- CoVault: Secure, Scalable Analytics of Personal Data