Skill Imitation Trap

• Skill Imitation Trap refers to a failure in learning where an agent successfully imitates observed behavior on familiar examples, but fails to acquire broader conditions, alternatives, transitions, or causal structure required for reliable execution, applicable across decision contexts.
• The trap often occurs due to factors like trajectory imitation overfitting, incompatible subskills, inappropriate behaviors, semantic abstraction losing critical information, demonstrative gaps, and inaccurate demonstrations.
• Mitigating mechanisms such as compositional imitation, semantic transfer, and accountability for skill demonstration provenance can help address the Skill Imitation Trap, ensuring that skills remain valid under varied conditions

Skill Imitation Trap is a failure mode in which an agent reproduces observed behavior or procedural regularities successfully on familiar examples while failing to acquire the broader conditions, alternatives, transitions, recovery strategies, or causal structure required for reliable execution. The trap appears in several forms: trajectory imitation can overfit embodiment, geometry, or simulator-specific contact patterns; compositional imitation can preserve incompatible subskills; behavioral priors can select familiar but inappropriate skills; semantic abstraction can discard execution-critical information; sparse demonstrations can conceal valid transitions; noisy demonstrations can encode harmful strategies; and self-evolving agents can transform attacker-induced behavior into persistent capabilities. The common structure is that imitation fidelity is mistaken for skill competence.

1. Conceptual foundations

A skill-imitation system observes demonstrations and constructs a policy, latent representation, controller, or persistent procedural artifact intended to reproduce useful behavior. Depending on the method, a skill may be represented as a trajectory, a short state-action segment, a task-space wrench sequence, a semantic label paired with an execution latent, a goal-conditioned policy, a keyframe, or a textual rule.

The central distinction is between reference reproduction and skill competence. Reference reproduction concerns similarity to observed states, actions, outputs, or procedures. Skill competence additionally requires execution under altered initial states, perturbations, embodiment, dynamics, object configurations, temporal phases, task orders, or environmental conditions. This distinction is explicit in interaction-based settings: a policy can obtain high normalized imitation reward on reference-like data while achieving poor neighborhood and transition success (Yu et al., 4 May 2025). Similarly, high imitation quality on flat-terrain trajectories does not imply robust locomotion on rough terrain (Wei et al., 16 Mar 2026).

A useful abstract formulation is:

$$\text{demonstration evidence} \longrightarrow \text{learned representation} \longrightarrow \text{execution policy}.$$

The trap occurs when the learned representation preserves correlations present in the demonstrations without preserving the conditions under which the behavior is valid. In such cases, the policy may imitate the wrong action, apply a skill outside its validity range, terminate in a state incompatible with the next skill, or reproduce a harmful local strategy.

The trap has both statistical and control-theoretic dimensions. Statistically, demonstrations provide incomplete and potentially biased coverage. In control, small deviations can change contact modes, destroy grasp configurations, or make later states unreachable. In hierarchical systems, a locally successful action can reduce the probability of global task completion. In self-evolving agents, the problem also becomes a security issue: observed behavior can be abstracted into a reusable artifact whose provenance and legitimacy are unclear.

2. Principal mechanisms

Embodiment and reality gaps

Contact-rich assembly exposes the limitations of direct trajectory imitation. Human demonstrations may encode implicit force-sensitive strategies for resolving tilting, collision, friction-induced jamming, and misalignment. A robot-independent assembly method therefore learns object-relative motion to task-space force and torque sequences rather than robot-joint trajectories. The learned sequence is executed through virtual forward dynamics, Cartesian force control, and force/torque feedback (Scherzinger et al., 2019).

This architecture avoids dependence on robot-specific joint trajectories and excludes simulated contact forces from the neural-network input. Nevertheless, its generality remains bounded by the cube-and-plate geometry, clearance regime, simulated contact dynamics, robot kinematics, controller assumptions, and force-sensor configuration. The representation is robot-independent only in the limited sense that robot-specific kinematics are confined to execution. It does not establish independence from robot morphology, manipulability, payload, friction, or control bandwidth.

Covariate shift and behavioral drift

Behavior cloning is trained on states visited by demonstrations. Once autonomous execution deviates from that distribution, subsequent states may be unfamiliar. This produces compounding errors. FIST addresses the problem by retrieving the closest downstream demonstration state, looking ahead by a fixed horizon, inferring a future-conditioned skill, and repeatedly reanchoring execution to the demonstration manifold (Hakhamaneshi et al., 2021). Its semi-parametric structure combines a learned skill decoder with non-parametric lookup.

The method reduces drift but does not eliminate it. A poor distance metric can retrieve the wrong state; a missing transition can require extrapolation; fixed-length skill windows can cut across semantic boundaries; and demonstrations can become behavioral attractors. The PointMaze oracle results show that future-state selection remains a bottleneck even when success is high. FIST is therefore better characterized as demonstration-grounded replanning than as unconstrained task planning.

State alignment and receding-horizon MPC provide a related mitigation for one-shot fabric manipulation. The controller estimates cloth keypoints, aligns the current state to a demonstration video, predicts a prior action sequence with inverse dynamics, samples feasible candidates, and executes only the first action (Huo et al., 2023). This avoids direct action copying and permits feedback correction. However, it remains dependent on keypoint observability, object-pose registration, contact-free dynamics priors, manually designed action constraints, and the assumption that the demonstrated state sequence is desirable. A visually similar state can still have different contact topology, grasp geometry, or recovery requirements.

Local success and global incompatibility

Divide & Conquer Imitation Learning makes the local/global distinction explicit. A complex trajectory is divided into goal-conditioned skills, and one shared policy is trained to execute them sequentially. The difficulty is that the success-state set for one goal can be larger than the subset of states from which the next skill is executable:

$$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$

A policy that merely reaches $g_i$ may leave the system with an unsuitable orientation, velocity, contact configuration, or pose. DCIL addresses this with a chaining reward bonus based on the value of the successor skill and with overshoot rollouts that train later skills from states actually reached by earlier skills (Chenu et al., 2022). The reported Dubins Maze results demonstrate that positional success with an incorrect orientation can prevent continuation through the next corridor.

The approach remains dependent on a designer-provided goal projection, mechanically extracted boundaries, environment resets, critic accuracy, and a fixed skill order. It does not learn a general task graph, automatically discover semantic boundaries, or provide arbitrary recovery after failure.

Latent composition and interference

Latent-space composition methods attempt to acquire complex behavior from simpler skills. In the compositional CVAE approach, simple-skill embeddings are added:

$V=\sum_{i=1}^{M} z_i.$

The method uses mutual-information regularization to make generated trajectories informative about the component embeddings (Pasula, 2020). It improves state-trajectory mean squared error and training speed on selected humanoid tasks.

Additive composition, however, is commutative and does not explicitly encode temporal ordering. Individually successful skills may be physically incompatible when executed concurrently. The method also assumes approximately independent Gaussian subskill latents, although concurrent skills may be correlated by timing, balance, or physical coordination. Consequently, improved trajectory similarity does not establish causal compositionality, task success, or robustness to incorrect decompositions.

FIST, XSkill, LOTUS, and DuSkill use alternative forms of structured skill representation. FIST uses future-conditioned latent transitions; XSkill separates a semantic skill identity $k$ from an execution latent $z$; LOTUS uses recurring temporally extended visuomotor policies and a language-conditioned meta-controller; and DuSkill separates domain-invariant and domain-variant latent factors before decoding skills with guided diffusion (Hakhamaneshi et al., 2021, Xu et al., 2023, Wan et al., 2023, Kim et al., 2024). These mechanisms reduce some composition failures but retain dependencies on representation coverage, state correspondence, segmentation, target-domain data, and decoder support.

Sparse, noisy, and incomplete demonstrations

Sparse demonstrations can omit valid alternatives, transition behavior, recovery strategies, and neighboring states. SkillMimic-V2 treats demonstrations as anchors within a larger physically feasible trajectory set rather than as a complete behavioral distribution. Its Stitched Trajectory Graph connects disconnected skill fragments, its State Transition Field assigns perturbed states to directed continuations, Adaptive Trajectory Sampling emphasizes low-reward clips, and a History Encoder represents phase-dependent behavior (Yu et al., 4 May 2025).

The empirical distinction between reference fitting and broader competence is substantial. On BallPlay-M, the baseline SkillMimic obtains average normalized reward $0.46$ but only $53.3\%$ reference-state success, $18.3\%$ neighborhood success, and $15.1\%$ transition success. The full method reaches $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$0, $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$1, and $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$2 on the corresponding metrics. The results support structured expansion of the imitation distribution, but the generated trajectories remain bounded by the state representation, similarity metric, perturbation radius, masking scheme, and simulator.

Noisy demonstrations create a separate quality trap. Standard behavior cloning treats noisy actions as equally valid labels. SDIL instead discovers localized action primitives from clean and noisy demonstrations, uses mutual-information regularization to separate them, and adapts the high-level controller using clean data (Zhao et al., 2023). Its sub-demonstration optimality estimator distinguishes clean-associated, noisy-associated, and shared skills.

This mitigates trajectory-level quality assumptions but does not provide a calibrated probability of optimality. Clean demonstrations are treated as correct, harmful behaviors can be shared by clean and noisy data, and mutual information makes skills identifiable rather than desirable. In healthcare data, outcome-based clean/noisy partitions can also contain confounding and selection bias.

3. Abstraction, generalization, and continual learning

Semantic over-abstraction

Semantic transfer avoids copying embodiment-specific motion. STAR transfers a discrete semantic skill ID $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$3 while learning target-domain execution through a continuous latent $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$4 and a target-domain low-level policy (Pertsch et al., 2022). Cross-domain state matching uses semantic skill distributions rather than pixels, coordinates, or robot configurations. Online reinforcement learning can shift toward a task-agnostic target-domain prior when the agent leaves demonstrated support.

The approach succeeds in transferring human-video demonstrations to simulated robot manipulation and in handling partial demonstrations. Yet a semantic label such as “open microwave” omits approach direction, gripper choice, force, timing, object state, collision avoidance, and recovery. If the target domain lacks the relevant affordance or low-level execution mode, semantic correspondence does not make the skill realizable. Incorrect action-recognition labels and ambiguous state matches can cause the robot to imitate the wrong intent.

XSkill similarly learns cross-embodiment skill prototypes from unlabeled human and robot videos and conditions a diffusion policy on continuous representations (Xu et al., 2023). Its Skill Alignment Transformer selects the prompt skill appropriate to the robot’s current state, thereby avoiding fixed-speed sequence replay. However, prototypes are learned from visual regularities rather than explicit causal structure, and the robot policy remains bounded by teleoperation-data coverage. Novel transitions absent from robot data remain difficult.

Similarity-derived skill discovery

LOTUS uses DINOv2 features, temporal segmentation, spectral clustering, replay, and a meta-controller to build a continually expanding skill library (Wan et al., 2023). It improves forward transfer and reduces negative backward transfer on LIBERO benchmarks. Its skills can transfer across objects, tasks, and task order.

The same mechanism can become a trap when visual similarity is not causal similarity. DINOv2 features may cluster segments with similar appearance but different contact forces, affordances, or task meanings. Recurrence can favor common behavior rather than necessary behavior, and incorrect assignment of new data to an existing skill can cause negative transfer. Replay reduces forgetting but imposes a memory burden and does not guarantee preservation.

KiRAS uses keyframes and self-generated premium trajectories rather than expert trajectory datasets. It learns flat-terrain skills from keyframe-guided self-imitation, then disables self-imitation during rough-terrain reinforcement learning and uses an Environment Context Estimator to adapt the same policy (Wei et al., 16 Mar 2026). Proficiency-based Skill Initialization increases sampling for under-trained skills, mitigating collapse toward easy gaits.

Keyframes reduce demonstration burden but replace full-trajectory dependence with sparse, manually chosen objectives. Static keyframe repetition can cause posture overfitting and temporally incoherent behavior. Terrain adaptation remains initialized from flat-terrain behavior and is constrained by a residual penalty relative to the flat policy. Autonomous skill selection is not yet learned; switching is command-driven.

Domain variation and decoder bottlenecks

DuSkill addresses domain mismatch by hierarchically encoding domain-invariant behavior and domain-variant factors, then using guided diffusion to generate skills from combinations of those representations (Kim et al., 2024). In Meta-World speed, energy, and wind domains, its reported average performance degradation is approximately $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$5, compared with approximately $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$6 for FIST. Its frozen decoder reduces few-shot overfitting and protects the learned behavior model.

The method does not establish safe extrapolation beyond the offline data. Diffusion can interpolate or recombine observed factors without generating valid behaviors outside support. Freezing the decoder prevents decoder destruction but also prevents correction of systematic decoder errors. The factorization into invariant and variant components is not identifiable from the reported evidence; t-SNE visualization is qualitative.

Lifelong retention and interference

Continual skill systems face a tension between reuse and negative transfer. A shared policy can exploit previously learned structure but can also collapse skill distinctions or overwrite earlier behaviors. LOTUS addresses this through incremental clustering and replay. KiRAS uses proficiency-based skill sampling. Both mechanisms are empirical rather than formal guarantees.

A skill library may also become a repository of unsafe or undesirable procedures. The problem is not limited to locomotion or manipulation. In self-evolving LLM agents, persistent skill artifacts can encode procedures, recovery rules, validation requirements, and tool-use conventions. The library’s growth can therefore increase capability and exposure simultaneously.

4. Security manifestations

Behavioral reconstruction

In agent services, a proprietary skill may remain hidden as a file while its functionality is observable through execution trajectories. SigLeak reconstructs such skills by generating diverse, decision-rich benign probes, comparing skill-enabled and skill-disabled trajectories, synthesizing a candidate skill, and iteratively refining it (Geng et al., 28 Jul 2026).

The attack targets recurring signatures in requirement interpretation, tool selection, ordering, validation, error recovery, file preservation, and output formatting. Its SkillSim metric evaluates coarse and fine-grained semantic similarity, while downstream success measures whether the inferred skill improves task performance.

Across five scenarios, SigLeak improves success over the skill-disabled reference by an average of $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$7 percentage points. Its inferred skills achieve the highest average fine-grained F1 of $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$8 and recall of $$\mathcal I_i^{\mathrm{valid}} \subsetneq \mathcal S_{g_i}.$$9 in the reported comparison. The finding illustrates a direct version of the trap: useful behavior exposed through ordinary interaction can become a training set for functional cloning even when prompts, files, and internal states remain hidden.

SkillClone studies a related threat, Behavioral Skill Reconstruction, in which a normal user forms an interface hypothesis, issues structured task-valid probes, synthesizes an executable replica, and validates it through differential querying (Hua et al., 4 Aug 2026). The target can consist of thresholds, lookup tables, formulas, procedures, or algorithms. Successful clones can exhibit $g_i$0–$g_i$1 attack success rates despite only $g_i$2–$g_i$3 token precision relative to the hidden skill body, showing that functional recovery need not resemble textual copying.

These results distinguish artifact secrecy from behavioral secrecy. Disclosure filters may block requests for SKILL.md while failing to prevent cumulative inference from legitimate outputs. The vulnerability is strongest when skills implement deterministic procedures, tables, thresholds, or formulas and when the interface exposes detailed tool calls, intermediate outputs, and validation behavior.

Trajectory poisoning and persistent backdoors

SkillJack and Trajectory Backdoor Attack show that the trap can operate in the opposite direction: rather than extracting a hidden skill, an attacker can cause a trusted self-evolving system to learn malicious behavior as a skill.

SkillJack models a pipeline in which experience is loaded, transformed into a skill, persisted, and routed to future queries. Malicious behavior can undergo sanitization whitewashing, in which suspicious intent is replaced by neutral procedural language; cross-layer promotion, in which transient experience becomes a persistent capability; and persistence isolation, in which deleting the original experience does not remove the derived skill (Ying et al., 4 Aug 2026).

In the reported SkillX setting, LLM-judge detection fell from $g_i$4 for raw framed trajectories to $g_i$5 for extracted framed skills. The derived skills achieved a routing-level attack success rate of $g_i$6 on attack-oriented tasks and $g_i$7 on clean tasks. In Anything2Skill, the downstream attack trigger rate reached $g_i$8 in the reported DOC configuration. These are routing-level or policy-violation proxy measurements, not live-compromise rates.

Trajectory Backdoor Attack uses ordinary queries to induce a trusted executor to produce explicit condition–action rules, repeats the pattern across triggered and clean tasks, and relies on the evolver to consolidate it (Luo et al., 8 Aug 2026). The attack preserves clean task utility while adding a malicious action under a trigger. Macro-average triggered attack success rates reach $g_i$9 for SkillOpt and $V=\sum_{i=1}^{M} z_i.$0 for Trace2Skill, close to direct skill injection despite the attacker having no direct write access.

The security interpretation is that an agent’s learning mechanism can become an attack amplifier. Repeated behavior is normally evidence for reusable expertise; under poisoning, recurrence and task preservation make malicious behavior appear intentional, general, and safe to retain. Cross-user skill evolution increases the risk because one user’s trajectory can influence another user’s future execution.

5. Boundary-aware and verification-oriented responses

A general mitigation principle is to represent not only what a skill does, but also when it should not be used. Boundary-Aware Skill Memory augments success-distilled skills with applicability conditions, risk cues, avoidance rules, and recovery notes (Lin et al., 23 Aug 2026). This changes a retrieved skill from an unconditional action template into state-conditioned guidance.

The motivation is supported by probe analyses showing that procedure skills raise the wrong-tool margin by $V=\sum_{i=1}^{M} z_i.$1 over a memory-free baseline on tasks that resemble prior successes but require different tools. BASM improves task success by up to $V=\sum_{i=1}^{M} z_i.$2 on AppWorld, accuracy by up to $V=\sum_{i=1}^{M} z_i.$3 on BFCL, and reduces attack success rate by $V=\sum_{i=1}^{M} z_i.$4 on AgentDojo. The method also reduces average AppWorld steps by up to $V=\sum_{i=1}^{M} z_i.$5 relative to the memory-free baseline.

Boundary fields address a central source of the trap: semantic similarity is not validity. A robust skill representation should include:

• Applicability conditions: states, objects, tools, or task structures under which the procedure is valid.
• Risk cues: observations indicating that the current situation differs from the demonstration regime.
• Avoidance rules: actions or tools that should not be selected under specified conditions.
• Recovery notes: procedures for failed execution, ambiguous state, or unexpected outcomes.
• Provenance: demonstrations, users, model versions, transformations, and authorization contexts that contributed to the skill.
• Validation evidence: held-out tasks and counterfactual evaluations supporting the rule.

Skill-level quality control should be distinguished from behavior-level validation. A textual skill can be coherent yet operationally harmful; a semantically accurate rule can still be inappropriate for a particular state; and a locally successful patch can overfit its originating task. SKILL-KD addresses this through student–teacher contrast, student reruns, bounded patch refinement, and trace-linked consolidation (Shi et al., 30 Jul 2026). Its patch is accepted only when the frozen student improves on the originating task, while historical traces support add, modify, delete, or skip decisions.

The approach improves both students on five benchmarks. In the smaller-student setting, its average score is $V=\sum_{i=1}^{M} z_i.$6, compared with $V=\sum_{i=1}^{M} z_i.$7 without skills, $V=\sum_{i=1}^{M} z_i.$8 for student-only reflection, and $V=\sum_{i=1}^{M} z_i.$9 for teacher-only distillation. Consolidation reduces the learned library to 38 rules and 3,010 words in the reported ablation, while removing consolidation degrades performance on procedural and multi-step tasks.

The method still depends on evaluator correctness, teacher quality, textual interpretability, prompt-time skill loading, and validation on limited originating tasks. It reduces but does not eliminate overfitting and cross-task interference.

6. Evaluation criteria and unresolved controversies

The Skill Imitation Trap is difficult to assess because imitation metrics can reward the wrong property. State trajectory MSE measures similarity but not necessarily task success or robustness. Chamfer distance measures point-cloud similarity but does not establish correct contact topology. DTW and cosine similarity measure motion resemblance but do not guarantee terrain traversal. LLM-based semantic similarity can reward plausible wording while missing operational distinctions. Downstream success can itself be misleading if a policy exploits a reward without performing the intended skill.

Several papers therefore combine fidelity with robustness, transition, neighborhood, recovery, or task metrics. SkillMimic-V2 distinguishes reference-state success, perturbed-neighborhood success, transition success, and normalized reward (Yu et al., 4 May 2025). RGSD evaluates Cartesian error and Motion FID while examining whether variations remain semantically related to reference motions (Rho et al., 7 Oct 2025). KiRAS reports terrain success in addition to imitation similarity (Wei et al., 16 Mar 2026). LOTUS evaluates forward transfer, negative backward transfer, and area under the continual-learning curve (Wan et al., 2023). Security studies distinguish clean accuracy, triggered accuracy, attack success, detection, and functional similarity (Geng et al., 28 Jul 2026, Ying et al., 4 Aug 2026, Hua et al., 4 Aug 2026, Luo et al., 8 Aug 2026).

Several unresolved issues recur across methods:

1. Causal versus perceptual representation: visual or latent similarity may not encode affordances, contact dynamics, authorization, or task purpose.
2. Boundary discovery: fixed windows, equal arc-length segmentation, clustering, or keyframes may not coincide with semantic or dynamical skill boundaries.
3. Support and extrapolation: diffusion, interpolation, or latent composition does not guarantee valid behavior outside the demonstration manifold.
4. Quality attribution: clean demonstrations may be biased, noisy demonstrations may contain useful local behavior, and heuristic optimality scores may be confounded.
5. Composition order: additive latent operators and fixed skill sequences do not represent all temporal dependencies or interaction terms.
6. Recovery: many systems improve nominal execution but provide limited guarantees after severe perturbations, failed grasps, lost contact, or unavailable transitions.
7. Continual interference: replay, skill expansion, and proficiency-based sampling reduce forgetting but may create memory burdens or negative transfer.
8. Security and provenance: derived skills can outlive their source experiences, obscure malicious intent, or be reconstructed from ordinary use.
9. Evaluation leakage: a system can perform well on reference-like tasks while failing on held-out states, changed tools, new terrains, novel transitions, or benign queries that resemble prior tasks.
10. Objective exploitation: a policy may optimize imitation, reward, or similarity metrics without executing the intended behavior, as illustrated by downstream policies that stand still or preserve superficial posture while failing the task.

7. Broader significance

The Skill Imitation Trap does not imply that imitation learning is intrinsically unreliable. The cited work shows that imitation can be made more robust when demonstrations are treated as structured evidence rather than complete specifications. Effective strategies include object-relative wrench policies, future-conditioned skill selection, successor-value chaining, overshoot training, state-transition fields, historical encoding, semantic–execution factorization, target-domain adaptation, replay, keyframe-guided self-imitation, domain-factorized diffusion, contrastive skill distillation, and explicit skill boundaries.

The common design principle is:

$k$0

This requires separating at least four questions:

1. What behavior is represented?
2. Under which conditions is it valid?
3. How does it transition to and recover from neighboring behaviors?
4. What evidence supports its quality, safety, and provenance?

A skill representation that answers only the first question is vulnerable to the trap. It may encode a useful behavior without its preconditions, a semantic goal without its execution parameters, a local subtask without successor compatibility, or a successful trajectory without the deviations required for robustness.

In control and robotics, the strongest evidence against the trap comes from performance on perturbed initial states, unseen transitions, alternate embodiments, changed dynamics, rough terrain, and contact-rich failures. In LLM-agent systems, the relevant evidence includes held-out procedural cases, counterfactual tool choices, consolidation stability, provenance-aware revocation, and resistance to behavioral reconstruction or trajectory poisoning.

The broadest implication is that learned skills are not merely compressed demonstrations. They are operational models that determine future action selection. Compression can remove irrelevant detail, but it can also remove validity boundaries, causal context, or evidence of uncertainty. Generalization can make useful behavior reusable, but can also make an error, shortcut, or backdoor more persistent. Self-improvement can expand capability, but can also preserve and amplify untrusted behavior.

The Skill Imitation Trap is therefore best understood as a mismatch between observed success and validated competence. Escaping it requires systems that do not merely imitate what happened, but identify why it worked, when it should be applied, when it should be suppressed, how it should connect to subsequent behavior, and whether its provenance and consequences justify making it reusable.