acceptodds
Under review as a conference paper at ICLR 2027

From Agent Failures to Faulty Directives: Attribution-Based Aggregate Analysis of Skill Files

Abstract

Current agentic systems increasingly rely on suites of Skill files to provide task-specific capabilities and encode proprietary knowledge that may be absent from the model's training data. Consequently, inconsistencies and errors in these files can directly affect agent behavior, leading to user dissatisfaction or task failure. However, it remains challenging for agent developers to identify which parts of a Skill file cause failures or user dissatisfaction. To the best of our knowledge, we are the first to study how agent failures can be traced to Skill directives. We introduce SkillRoot , an execution-trace-driven framework that attributes agent actions to their supporting context and represents Skill content as a knowledge graph of directives, entities, and relationships. SkillRoot aggregates evidence from successful and failed executions to compute a failure-association prior over directives, which an LLM-based judge combines with a new failure trace to localize responsible Skill chunks. Across our evaluation, SkillRoot improves faulty-directive identification by up to 6% over standard baselines.

Primary area:
interpretability and explainable AI
Keywords:
Agentic System, Skill, Failure diagnosis

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_JAtqOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper introduces SKILLROOT, a framework for identifying faulty directives in Skill files used by LLM-based agents. To address the limited diagnostic information in conventional execution traces, SKILLROOT enriches each agent action with its supporting context—Skill content, task instructions, prior observations, or the agent’s own judgment—and records the relevant evidence. It then represents Skill directives, entities, and semantic relations in a knowledge graph, enabling related information distributed across the file to be analyzed jointly. By aggregating directive activations across successful and failed executions, the framework computes Ochiai-based suspiciousness scores for both individual directives and related directive groups. Finally, an LLM-based judge combines these historical priors with evidence from a new failure trace to identify the directives most likely responsible for the observed failure.

Critical strengths
  1. The paper addresses an important and under-explored problem by localizing faulty directives in Skill files, which increasingly serve as persistent, task-specific specifications for LLM-based agents. Unlike prior work that mainly identifies erroneous agents, actions, or steps within a single trajectory, SKILLROOT targets reusable instructions shared across executions. This formulation is practically meaningful because correcting one faulty directive may prevent an entire class of recurring failures.
  2. The paper presents a well-motivated combination of action-level attribution, cross-execution statistical analysis, and failure-specific LLM reasoning. Instead of asking an LLM to inspect a Skill file and a single failed trace directly, SKILLROOT first aggregates evidence from successful and failed executions to construct a suspiciousness prior. This design reduces reliance on unconstrained LLM reasoning and makes effective use of historical execution evidence.
  3. The Skill Knowledge Graph provides a structured representation of complex Skill files by connecting directives, entities, procedures, examples, dependencies, refinements, and contradictions distributed across different sections.
  4. The evaluation is reasonably comprehensive and supports the main claims of the paper.
Critical weaknesses
  1. The paper does not provide an empirical evaluation of efficiency or scalability, despite motivating SKILLROOT partly through the substantial token overhead of analyzing large trace collections with LLMs. The framework introduces additional costs at several stages, including action-level attribution and counterfactual generation for every tool call, LLM-based knowledge-graph construction, NLI-based trigger checking, co-occurrence search, and the final LLM judge. However, the paper reports neither token consumption nor wall-clock latency, API cost, storage overhead, or preprocessing time.
  2. The Ochiai score measures whether a directive is disproportionately active in failed executions, while the action-level attribution is self-reported by the executing agent and may reflect post-hoc rationalization. Consequently, a highly ranked directive may correlate with difficult tasks or failure-prone contexts without actually causing the failure. A stronger evaluation would repair or remove the predicted culprit directives and rerun the affected tasks to verify whether the failures are eliminated.
  3. The benefits of several components are not fully consistent across error types and judge models. The co-occurrence merge improves performance for Opus-4.6 but provides limited or mixed gains for GPT-5.5, while ambiguity remains difficult for all methods.
Questions for authors

Please refer to the Weaknesses

3 comments

W1. Empirical evaluation of SKILLROOT’s efficiency and scalability, including token consumption and other details

Please refer to our response to reviewer FYY4 W2 (a), Q2 for further details about the computational overhead and scalability of self attribution and other compoents.

W2. Distinguishing Faulty Directives from Those Correlated with Failures Due to Difficult Tasks

We thank the reviewer for raising this important question. We would like to clarify that SkillROOT does not aim to repair faulty Skill directives but rather to identify potentially responsible directives using historical evidence and their associated Ochiai suspiciousness scores. The final decision on whether a flagged directive should be removed remains with the agent developer, who can examine the evidence provided by SkillROOT.

We acknowledge that task difficulty may influence suspiciousness scores, as harder tasks may fail for reasons unrelated to the Skill directives. One possible extension is to incorporate task difficulty into Ochiai scoring by using a classifier or an LLM judge to estimate task complexity and assign lower weights to failures on harder tasks, thereby reducing their contribution to the suspiciousness score. This would allow the scoring mechanism to account for both historical execution outcomes and task difficulty. We will further explore this direction as part of our future work.

W3. Inconsistency of performance across judge model and error type.

We thank the reviewer for raising this insightful observation. The performance of our method varies across error types and RCA judge models, largely depending on two factors: (1) whether the available context (execution log and Skill file), together with the model's internal knowledge, is sufficient to identify the faulty directive, and (2) how the RCA judge utilizes the Ochiai suspiciousness scores alongside the provided context.

Across error types, the main benefit of our method arises when the execution log and Skill file alone do not provide sufficient evidence to identify the faulty directive. Contradiction and ambiguity errors are relatively easier to identify, as conflicting instructions are explicitly present in the Skill file, while ambiguous instructions can often be recognized from their wording and possible interpretations. In contrast, wrong-content errors are more challenging because verifying the correctness of a directive may require proprietary or domain-specific knowledge that is neither available in the execution log or Skill file nor part of the model's internal knowledge. Consequently, as the available contextual evidence becomes less sufficient to determine correctness, moving from contradiction and ambiguity to wrong-content errors, historical evidence becomes increasingly valuable, as it allows SkillROOT to contrast directive activations across successful and failed executions and identify which directives are predominantly associated with failures.

Similarly, different RCA judge models utilize the candidate directives, contextual information, and Ochiai scores differently. We observe that Opus tends to rely more heavily on Ochiai suspiciousness scores, whereas GPT-5.5 places greater emphasis on reasoning over the available context, relying on Ochiai scores primarily when contextual evidence is insufficient. These differences in model behavior, potentially arising from their training, are also reflected in our ablation results and help explain the variation in performance across models and error types. We will include this discussion in the revised manuscript.

Reviewer_JAtqOpenReview ↗

Response

I appreciate the authors' response. While W1 has been addressed and the remaining weaknesses have been partially resolved, my concern regarding the SKILLROOT limitation persists. I will maintain my score.

Dear Reviewer,

Thank you for your prompt response. We are glad that our additional results on computational efficiency and scalability have addressed your concerns.

Could you please share your remaining doubts or concerns regarding the other weaknesses you highlighted? We would be happy to provide further clarifications or additional experimental results to address them.

Thank you again for your time and constructive feedback.

Regards,

Authors

Reviewer_D2CMOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes SkillRoot, a framework for identifying faulty instructions in Agent Skill files. The method combines action-level attribution, a Skill Knowledge Graph, failure statistics from historical executions, and an LLM-based judge. The experiments cover three types of Skill errors: wrong content, contradiction, and ambiguity.

Critical strengths
  1. The paper studies a useful problem. Identifying faulty Skill instructions is more actionable than simply locating a failed execution step.
  2. The overall framework is clear and reasonably complete. Combining runtime evidence with historical success and failure records is a sensible approach.
Critical weaknesses
  1. The proposed method uses historical execution information that is not available to the main log-based baselines. It is therefore difficult to determine how much of the improvement comes from the historical evidence itself rather than the knowledge graph or co-occurrence analysis.
  2. The attribution is generated by the agent itself. The counterfactual descriptions are also self-reported rather than verified through actual interventions. Thus, these signals may reflect plausible explanations rather than the true causes of actions.
Questions for authors
  1. Does requiring attribution during execution change the agent’s behavior, task success rate, or inference cost?
  2. Can the authors evaluate generalization to unseen Skill errors and clarify the train/test separation?
  3. Which activation rule is used for conditional directives? Algorithm 2 and Appendix G.2 appear to give different definitions.
5 comments

W1. Unclear whether the performance gains arise primarily from historical evidence or other components.

We would like to highlight that Skill file analysis using the knowledge graph (KG) and historical execution evidence are two core components of SkillROOT. The KG not only extracts individual directives and their relationships from the Skill file but also enables entity-based attribution to determine whether a directive is active in a given execution log. These activations form the basis for computing directive-level Ochiai suspiciousness scores from historical executions. Without extracting and isolating individual directives, historical evidence cannot be used to compute their corresponding suspiciousness scores. Please refer to our response to Reviewer FYY4, Q1, for further discussion of the role of the KG and the recall-based analysis.

Other components, including self-attribution, chunking strategies, and co-occurrence-based Ochiai scoring, are additional features whose contributions are evaluated through the ablations in Figure 6, Table 1, and Figure 8, respectively.

We would also like to emphasize that historical evidence is particularly valuable for wrong-content errors, where neither the Skill file nor an individual failed execution provides sufficient information for the RCA judge to assess whether a directive is correct. By comparing directive activations across successful and failed executions, SkillROOT can identify suspicious instructions even when their correctness cannot be determined from the available context alone. To the best of our knowledge, existing agentic RCA methods do not explicitly address this setting by combining directive-level Skill analysis with historical execution evidence. Please refer to Section 4.2 for further discussion.

W2. Self-generated attributions and counterfactual explanations may represent plausible rationalizations rather than the actual causes of agent actions.

We thank the reviewer for the insightful question. We agree that interventional analysis provides stronger evidence of causality and can establish an agent's dependence on specific directives. However, applying such analysis to agentic systems presents two key challenges.

First, the computational cost can be substantial. A Skill file may contain tens of directives, each used across different historical executions. Removing or modifying each directive and rerunning the associated tasks would require a large number of additional agent executions, making exhaustive interventional analysis expensive.

Second, agent behavior is stochastic, making the effect of an intervention difficult to isolate. Removing a directive may not change the outcome if similar information appears elsewhere in the Skill file or the agent can infer the same action through its own reasoning. Conversely, an intervention may cause a task to fail entirely, making it difficult to assess the original directive's contribution.

To further investigate whether agent-generated self-attributions are causally grounded, we conducted an additional intervention study over 50 execution traces. For each trace, we identified the first Skill attribution generated by the agent and removed the cited passage from the Skill file. We then regenerated the corresponding action while keeping all preceding actions and execution history unchanged, allowing us to isolate the effect of removing the attributed passage. We compared this intervention against two controls: (1) placebo, where an uncited passage was removed, and (2) resampling, where the agent was rerun with the same history without modifying the Skill file.

A Claude Opus 5.5 judge compares the original action with regenerated actions and determines whether it is functionally equivalent to the original action (same tool, effect, parameters and others). Differences in wording, formatting, and attribution are ignored. An action is marked as changed only when the agent makes a functionally different decision.

Table E: Effect of Skill passage removal on agent decisions.

ConditionAgent Decision Changed
Resample (no edit)1.6%
Placebo (uncited passage removed)9.5%
Cited passage removed44.2%

The results show that removing the cited passage changes the agent's decision in 44.2% of cases, compared to 9.5% for placebo removal and 1.6% for resampling. This provides interventional evidence that agent-generated self-attributions often identify Skill directives that genuinely influence the agent's actions rather than merely serving as post-hoc explanations. Importantly, multiple passages within a Skill file may convey similar information and influence the same action. Removing a single cited passage may therefore leave equivalent information elsewhere in the file, allowing the agent to make the same decision. Thus, our experiment demonstrates a change in at least 44.2% of the evaluated cases following removal of the cited passage, while the true influence of the attributed information may be higher. A more comprehensive intervention would identify and remove all related passages conveying the same information, which we will pursue as part of our future work. We will include these findings and limitations in the revised manuscript.

Q1. Does requiring self-attribution during execution affect agent behavior, task success rates, or inference costs?

We would like to highlight that the modifications required for self-attribution are introduced at the tool-call schema level rather than through changes to the system prompt. This design allows us to leverage the tool-use capabilities of foundation models, as demonstrated by Toolformer [1], where models learn to interact with external tools while retaining their general language modeling capabilities. In our case, the schema extension can be viewed as incorporating a new tool-like requirement that explicitly asks the agent to provide self-attribution as part of the Pydantic schema, without modifying the underlying tool functionality. Recent work [2] further demonstrates that LLM agents can adapt to evolving toolsets while largely preserving their existing capabilities.

To examine the impact of these schema modifications on agent behavior, we conducted an ablation over 30 tasks, each executed once with and without self-attribution. As shown in Table F, 29 out of 30 subtasks (96.7%) retained the same success/failure outcome This suggests that the schema modifications largely preserve the agent's task performance.

Table F: Task-level outcome consistency with and without self-attribution.

Outcome (With → Without Self-Attribution)Number of Subtasks
Success → Success21
Failure → Failure8
Failure → Success1
Success → Failure0
Unchanged outcomes29 / 30 (96.7%)

For the detailed computational cost and token overhead analysis, please refer to our response to Reviewer FYY4, W2(a), Q2.

References

[1] Toolformer: Language Models Can Teach Themselves to Use Tools, NeurIPS 2023.

[2] Beyond Static Toolsets: Self-Evolving LLM Tool Agents via Continual Documentation Adaptation, Findings of ACL 2026.

Q2. How well does the proposed approach generalize to unseen skill errors, and what is the train/test separation in the evaluation?

We would like to clarify that SkillROOT does not involve any model training. It operates at runtime, using historical execution logs to identify faulty Skill directives. The ground-truth faulty directives are used exclusively for evaluation across the applications described in Section C and are never exposed to the RCA pipeline.

Our K-fold cross-validation evaluates generalization to unseen execution logs within the same application. In each fold, one failed execution log is held out for evaluation, while the remaining logs and their binary success/failure outcomes are used to compute historical Ochiai suspiciousness scores. Neither the agent nor the RCA judge is trained on these logs or their associated errors, and the ground-truth faulty directives are used only to evaluate the RCA predictions.

Since no training is involved and evaluation is performed on held-out execution logs and associated skill error, we expect SkillROOT to generalize to unseen Skill files without retraining.

Q3. What activation rule is used to determine whether a conditional directive is applicable during execution?

We thank the reviewer for bringing this to our attention. Conditional directives specify both when an instruction should be triggered and what action should be taken once the condition is met. Relying solely on entity matching can lead to false positives, as entities associated with the action may appear in the execution log even when the triggering condition is not satisfied.

To address this, we first use entity matching to identify potentially active directives. For conditional directives, we additionally employ an LLM-based Natural Language Inference (NLI) checker to verify whether the triggering condition is satisfied in the execution log. A conditional directive is marked active only when both checks are satisfied, whereas unconditional directives rely on entity matching alone.

As described in Appendix G.2, we combine these checks by multiplying their binary outputs. We will clarify this distinction in the algorithm to ensure consistency with Appendix G.2.

Reviewer_FYY4OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Agents are increasingly rely on external Skill files for domain specific rules, and flaws in these files cause soft task failures that are tough to trace from a single log. To solve this, the authors propose SKILLROOT, which brings spectrum based fault localization to agent instructions. The method forces the agent to log which context source drove each tool call, links related rules in the Skill file using a Knowledge Graph, and computes scores across passing and failing runs to help an LLM judge find the bad directive.

Critical strengths
  1. Using multiple runs to localize faults in persistent agent prompts is well motivated. Many work mostly debugs single trajectories, which struggles when a proprietary rule has wrong content that still looks reasonable in isolation. Comparing directive activations across passing and failing runs solves this cleanly.
  2. Attributing decision turns to skill files is an interesting trick for black box models. Getting the agent to cite its source and state a counterfactual during tool calls works without needing model weights, and the analysis showing how agents shift between relying on the Skill file versus their own judgment across bug types is very insightful.
Critical weaknesses
  1. The Knowledge Graph pipeline feels over-engineered and fails to beat simpler baselines. In Table 1, simple paragraph chunking beats or ties the full Knowledge Graph variant in four out of six settings. On contradiction and ambiguity bugs, simply giving a single log and the Skill file to a judge without any historical priors or attribution works just as well or better. The gains mostly come from basic Ochiai scoring on wrong content errors.
  2. The benchmark is small and the runtime cost is not measured. The dataset only covers 34 synthetic diffs across 17 skill families. Also, forcing the agent to generate verbatim quotes and counterfactuals on every step adds token overhead and could drastically change how the agent acts, which is never evaluated.
  3. (Minor) Figure 1 and 3 are somewhat blurry and hard to read. I suggest the authors increase font size and resolution, and consider making fig 1 full line width.
Questions for authors
  1. Why does simple paragraph chunking beat the Knowledge Graph variant in so many cases, and does fine grained statement splitting strip away context that the judge needs?
  2. How much extra token cost and latency does schema enforced attribution add per run, and does it change the base task success rate compared to an unmodified harness?
  3. I suggest the authors to consider testing on real world Skill bug fixes from public git commit histories rather than clean synthetic edits. That would make the evaluation much more convincing.
5 comments

W1 (a). Benefits of the knowledge graph compared to simpler baselines.

We thank the reviewer for this observation. We would like to clarify that Ours (KG) and Ours (Paragraph) differ only in the context provided to the RCA judge, not in their use of the knowledge graph. Ours (KG) provides individual directives (typically 1–2 lines) with their Ochiai scores, whereas Ours (Paragraph) provides the corresponding full paragraphs with the same scores. The stronger performance of the latter suggests that surrounding context helps the judge interpret directives and identify faults more accurately. Thus, this comparison is primarily an ablation of the context provided to the RCA judge, rather than the contribution of the KG itself.

Importantly, both variants use the KG for three purposes:

  1. Directive extraction and relationship modeling: The KG extracts directives and models their relationships, consolidating repeated information and helping developers identify dependencies and potential contradictions.
  2. Directive activation and attribution: Keywords associated with KG directives help identify their activations across execution logs. Combined with agent self-attributions, these form the historical evidence used to compute Ochiai scores.
  3. Candidate enrichment: As described in Algorithm 1, the KG expands the shortlisted candidates with related directives, improving the coverage of potentially faulty directives before RCA judgment.

To further quantify the contribution of the KG in enriching the recall in the candidate list provided to the RCA judge, we evaluate how multiple hop over the KG improves the recall of the candidate list..

Table A : Recall of the candidates provided to RCA judge based on KG hops

Error TypeHops = 0Hops = 1Hops = 2
Wrong Content0.7190.8810.951
Contradiction0.8330.8670.967
Ambiguity0.3120.5070.806

KG-based expansion consistently improves candidate recall across all error types. These improvements are particularly important because candidate recall upper-bounds the recall achievable by the RCA judge, which can only select faulty directives present in its shortlist.

W1 (b). Comparable performance of the single-log and skill-file baseline on contradiction and ambiguity errors.

We thank the reviewer for this observation. We believe the comparable performance of single-trace baselines on contradiction and ambiguity errors is largely explained by the nature of these errors.

For contradictions, the Skill file itself contains conflicting directives, while the execution trace reveals which directive the agent followed. This often provides sufficient evidence for the RCA judge to identify the conflict without relying on historical executions. Similarly, ambiguities can often be detected by reasoning about the multiple possible interpretations of an instruction.

In contrast, wrong-content errors involve incorrect information that may not be apparent to the foundation model from its pretrained knowledge. Since the instruction can appear internally consistent and unambiguous, examining a single trace and Skill file may not reveal the error. Here, historical evidence becomes particularly valuable, as comparing successful and failed executions helps identify directives disproportionately associated with failures. The KG further supports this analysis by consolidating references to the same information across the Skill file and tracking directive activations across execution traces.

Thus, while single-trace analysis can be effective for errors identifiable from the Skill file itself, our framework is particularly beneficial for wrong-content errors, where fault localization requires evidence beyond the content of an individual execution.

W2 (a), Q2. Lack of runtime cost analysis.

We thank the reviewer for raising important questions about the computational overhead and scalability of our approach. To address these concerns, we distinguish between runtime overhead introduced by self-attribution during agent execution and offline RCA costs incurred when analyzing historical execution logs. Table A reports the token consumption and API cost of each component of SkillROOT for analyzing 10 execution logs, using GPT-5.5 or Opus 4.6 as the RCA judge.

Table B: Offline RCA cost per instance (10 execution logs). Prices are in USD per million tokens.

ComponentModelInput tokensOutput tokensPrice ($/M)Cost
Build skill knowledge graph (once per skill)GPT-5.4-mini16,7359,959In: 0.75; Out: 4.50$0.057
Statement activation check (10 logs)GPT-5.4-mini63,033630In: 0.75; Out: 4.50$0.050
Ochiai ranking—00—$0
Judge reads 1 failing log + ranked candidatesGPT-5.5 / Opus 4.67,352 / 7,208365 / 593In: 5.00; Out: 30.00 / 25.00$0.048 / $0.051
Total offline RCA cost————$0.155 / $0.158

For runtime overhead, we conducted an ablation over 30 paired subtasks using Sonnet 4.6, with and without self-attribution. Runtime costs are calculated across the four tools used in the experiment, with prefix caching for the self-attribution schema. As shown in Table B, self-attribution introduces an average additional latency of 13.2 seconds and an API cost of $0.033 per execution log.

Table C: Runtime overhead of self-attribution per execution log (30 paired subtasks).

Metric (Mean per Execution Log)Attribution OnAttribution OffOverhead
Execution time71.5 s58.4 s+13.2 s
LLM calls9.18.3+0.8
API cost (prefix-cached)$0.172$0.138+$0.033

To further examine scalability, we compare SkillROOT against a baseline that directly provides all historical execution logs and the Skill file to the RCA judge. As shown in Table C, the cost advantage of SkillROOT increases as the number of historical logs grows. Unlike the baseline, which processes the entire execution history, SkillROOT aggregates historical evidence through statement activation and Ochiai-based ranking, reducing the amount of context required by the final RCA judge. With 50 execution logs, SkillROOT is approximately 3.25× cheaper with GPT-5.5 and 1.63× cheaper with Opus 4.6, including runtime self-attribution overhead.

Table D: RCA cost scaling with the number of historical execution logs (USD).

LogsBaseline Input TokensBaseline Cost (GPT-5.5 / Opus 4.6)SkillROOT Offline (GPT-5.5 / Opus 4.6)Runtime OverheadSkillROOT Total (GPT-5.5 / Opus 4.6)Cost Saving (GPT-5.5 / Opus 4.6)
10133,653$0.679 / $0.683$0.155 / $0.158$0.334$0.489 / $0.4921.39× / 1.39×
20264,513$1.334 / $1.337$0.205 / $0.208$0.668$0.873 / $0.8761.53× / 1.53×
50657,093$6.587 / $3.300$0.356 / $0.359$1.670$2.026 / $2.0293.25× / 1.63×

Note: GPT-5.5 doubles its input price above 272K tokens, while Opus 4.6 retains standard pricing.

Overall, SkillROOT reduces the cost of analyzing historical execution logs by aggregating evidence before passing it to the final RCA judge, while introducing an additional runtime overhead of approximately 13.2 seconds and $0.033 per execution log. Furthermore, knowledge graph construction is performed only once per Skill file, and historical execution records can be reused across multiple RCA analyses, allowing these costs to be amortized. We will include this analysis and the associated scalability discussion in the revised manuscript.

W2 (b). Impact of self-attribution on agent behavior.

Please Refer to our response to reviewer D2CM Q1. for further details.

W3 : Change the figure style in the main draft.

Thanks for bringing this to our attention we will change the figure as per the reviewer's suggestion.

Q1. Why does paragraph-based chunking outperform the knowledge graph approach in several cases, despite its simpler representation?

Directives extracted from the Skill file into the knowledge graph typically span only one or two lines, making it difficult for the RCA judge to assess their validity based on the individual statements alone. In contrast, providing the entire paragraph preserves not only the context of the instruction but also the surrounding sentences, related directives, and examples that help explain why a particular instruction exists and how it should be interpreted. This additional context allows the RCA judge to better reason about the validity of the instruction, together with the historical evidence captured by the Ochiai suspiciousness score.

Comments on the paper

1 comment

General comment

We thank all the reviewers for their constructive feedback. We appreciate their recognition of the importance and practical relevance of localizing faulty directives in persistent Skill files, as well as their positive assessment of our use of historical execution records, self-attribution, the Skill Knowledge Graph, and the novelty of our approach.

In our rebuttal, we have addressed the reviewers' main concerns regarding interventional analysis, potential changes in agent behavior due to self-attribution, and the associated runtime and computational overhead. We look forward to further discussion with the reviewers.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.