Pith. sign in

REVIEW 4 major objections 5 minor 33 references

TraceCompiler: Skill-Guided Mining and Compilation of LLM Agent Traces into Mostly Deterministic Workflows

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Recurring agent intents can be compiled into mostly deterministic workflows by admitting an inter-tool dependency only when a consumer argument contains a value uniquely attributable to an earlier producer.

desk verdict Plausible and unusually honest agent-trace compilation paper; the central exclusion mechanism is not actually measured yet, but the authors mostly say so themselves. read the letter →

arxiv 2608.02680 v1 pith:3CNEMP6F submitted 2026-08-03 cs.SE cs.AIcs.LG

Salma El Yadouni (EPFL) , Guanyi Li (Binome Technologies) This is my paper
classification cs.SEcs.AIcs.LG
keywords LLMagentsworkflowcompilationdependencyminingtracedenoisingargumentprovenanceproducer-consumerdependenciespartialobservabilityprocessdiscovery
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Tool-using language-model agents repeatedly rediscover the same procedures, mixing reusable structure with retries, exploration, and repeated lookups. TraceCompiler mines clusters of noisy traces and compiles them into executable workflows that keep only evidence-backed structure, with ambiguous relations marked as suspected and imposing no ordering constraint. Its central rule admits an ordering edge between two tool calls only when an argument of the later call contains a value that only the earlier call could have produced, and every hard edge carries an auditable evidence tuple. On a template-generated corpus the mechanized rule recovers producer-consumer dependencies at 0.928 precision and 0.943 recall over 15,775 edges, beating order-based and frequency-based baselines; a compiled Venmo request intent drops from 34 observed API calls to 11 runtime calls and passes 15 of 21 state tests on withheld instances. The paper also shows the compiler correctly refusing to compile an intent whose irreversible side effect is under-determined, treating abstention as a safety property rather than a failure.

What carries the argument

The argument-level dependency rule operating over canonicalized tool calls: for each consumer argument value, scan all earlier calls as candidate producers, require uniqueness against user input, static context, schema defaults, and every other prior call, and attach an evidence tuple to each retained hard edge. The rule is implemented both as a deterministic mechanized program and as a versioned LLM skill; provenance classification (constant, user input, copy edge, transform, or LLM decision) and the suspected downgrade carry the abstention behavior.

What would settle it

Generate traces of the same recurring intent using several different agents with deliberately different exploration and retry habits, compile each set, and compare the recovered dependency graphs; if the graphs diverge materially, the assumption that traces reflect task structure rather than agent habits is refuted. Alternatively, build a corpus with decoy tokens or mask every identifier-shaped literal so that token presence is no longer an almost-perfect dependency signal, and check whether the exclusion test actually fires and keeps precision high.

Watch

Extended reading notes

Core claim

The paper claims that recurring agent behavior can be separated from accidental execution history by an admission-by-exclusion dependency test: an edge from tool a to tool b is retained only when some argument of b consumes a value attributable uniquely to a, with every hard edge carrying an auditable evidence tuple and ambiguous relations downgraded to suspected, which imposes no ordering constraint. If true, agent intents need not be re-derived on every request; evidence-backed structure can be compiled into programs that leave only genuinely open decisions to a runtime model, reducing tool calls and removing retries, exploration, and schema lookups while abstaining on under-determined side effects.

Load-bearing premise

The load-bearing premise is that the traces being mined are evidence about the task's true structure rather than the habits of the single agent that produced them; if a different agent were used, the recovered dependencies and compiled workflows might not transfer.

Editorial extensions

If this is right

  • Dependency recovery beats adjacency (0.711 F1) and a frequency-thresholded directly-follows measure (0.712 F1) by a wide margin, since ordering alone cannot distinguish consumption from coincidence.
  • Compiled workflows can remove retries, schema lookups, and pagination loops without flattening genuine fan-out, as shown by the Venmo intent's 34-to-11 call reduction.
  • When a required branch was never observed, the compiled workflow escalates rather than acts, and when an irreversible side effect is under-determined the compiler declines to emit an executable graph.
  • Only genuinely semantic bindings remain as runtime LLM nodes; everything else resolves at build time or through deterministic transforms.
  • No net efficiency result is claimed because offline compilation cost is not measured.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the premise that traces encode task structure rather than one agent's habits fails, compiled workflows will encode idiosyncrasy; testing on traces from multiple independent agents is the natural next experiment.
  • The abstention rate over the full 56-scenario AppWorld corpus, rather than two case studies, would be the adoption-relevant number, and the paper itself names it as the cheapest missing experiment.
  • The evidence tuples double as a training signal: the logged (cluster, workflow, evidence) triples are already the input a learned compiler could train on.
  • The same exclusion discipline could apply to human-in-the-loop approval boundaries, cleanly identifying which irreversible decisions are genuinely under-determined by available evidence.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. TraceCompiler mines clusters of noisy LLM-agent traces and compiles them into mostly deterministic workflows under partial observability. Its central discipline is admission by exclusion: an inter-tool edge is retained only when a consumer argument contains a value attributable uniquely to an earlier producer, with ambiguous relations marked suspected and imposing no ordering constraint. The paper reports a mechanized version of the rule on T1's training split (0.928 precision and 0.943 recall over 15,775 def–use edges, versus 0.711 and 0.712 F1 for order-based and recurrence-based baselines on identical data), a blind skill run at 0.992 on 250 edges, a replay-based AppWorld token-attribution check at 0.993 precision, two compiled-intent case studies (Venmo 34→11 with 15/21 leave-one-out state tests; Spotify/Todoist refusal to compile), and an intent-discovery evaluation. The paper is unusually candid: it withdraws earlier claims, labels the AppWorld reference a self-consistency check, states that the skill run is unaudited, and reports that the discovery table does not reproduce from the released corpus.

Significance. If the admission-by-exclusion discipline were validated, the system would be a significant contribution: auditable evidence tuples, explicit abstention on ambiguous relations, refusal to compile under-determined irreversible side effects, and conservative workflow compilation are valuable and distinct from order-based process discovery. The paper's strengths include a deterministic, recomputable mechanized comparison on identical data with Wilson intervals, a clear separation of what is deterministic versus model-dependent, honest self-corrections (branch necessity, AppWorld reference independence), and explicit statements of what is not claimed (no net efficiency result, no compile/decline rate, no conformance claim). However, the flagship measurement does not exercise the exclusion test, and the one run that does is a single unaudited observation; the significance is therefore conditional on closing that gap in a revision.

major comments (4)
  1. [§6.5, Table 3] The paper's central claim—that hard edges are admitted only by exclusion of alternative origins—is not supported by the flagship experiment. Section 6.5 reports that the zero-candidate count is exactly zero on T1, so the abstention branch never fires; the exclusion filter leaves a mean of 8.2 candidate producers per relation. Table 3 shows that replacing 'most recent survivor' with a random survivor drops precision from 0.928 to 0.403, while the unique-candidate row (the closest mechanized analogue of abstention) has recall 0.071. Thus Table 2 measures producer attribution by recency under co-reference, not admission by exclusion; the paper's own description as 'most recent survivor' concedes this. The central safety property requires an experiment in which the exclusion test actually fires and demonstrably improves accuracy or safe abstention on a corpus where dependency detection is not trivial.
  2. [§6.5, blind skill run] The only execution that exercises the full exclusion discipline is the skill's blind run at 0.992 on 250 edges, but this run is not auditable: the released prompt's sample cannot be identified from the released labelling, the per-edge predictions are not released, and the run is one observation of a stochastic LLM procedure. The paper is transparent about these gaps, but transparency does not supply the missing evidence. To support the claim that every hard edge carries auditable unique attribution, the authors should release the sample-selection mechanism and the per-edge predictions, or mechanize the type-compatibility and semantic-exclusion components so that the exclusion test can be recomputed.
  3. [§6.4, Table 1] The intent-discovery evaluation does not reproduce from the released corpus: re-running the released sweep gives 12 clusters at purity 0.548 rather than the reported 50 clusters at purity 0.930. The paper states that this is 'a measurement over a released artifact, not a reproducible result' and that regenerating the labelling or releasing the serialization is a prerequisite for treating the numbers as evidence. Because clustering is the first stage of the pipeline, the end-to-end claim 'traces → workflows' inherits this gap. The revision should either release the serialization or a regenerated labelling, or explicitly mark the discovery section as preliminary and refrain from using it to support the pipeline claim.
  4. [§7, Reproducibility and scope] The T1 adapter that produces the trace and edge files is not released, so a reader cannot verify how the def–use graph was computed or how masking was aligned to it. The paper itself identifies this as 'the step most worth auditing.' Because the 0.928/0.943 headline numbers depend entirely on that adapter, this is a load-bearing reproducibility gap, not a peripheral packaging issue. The revision should release the adapter or provide a detailed, checkable description of the def–use extraction and masking alignment.
minor comments (5)
  1. [§3.3 and Appendix A] The relation class 'conditional hard' appears in the main text's taxonomy but not in the skill's edge-verdict list in Appendix A; the appendix maps it to a hard edge on a guarded node, and that mapping should also appear in §3.3.
  2. [§5, Discovery parameters] The paper states that the discovery parameters (minimum intra-cluster similarity 0.45, support floor 5, recurrence threshold θ=0.6) are defaults rather than tuned optima, but no sensitivity sweep is reported; even a minimal sweep would help establish that the qualitative results do not hinge on these values.
  3. [Figures 2 and 3] Figures 2 and 3 use color-coded cells to distinguish schema discovery, retries, pagination, and fan-out; adding an explicit legend to each figure would make the raw-trace strips substantially easier to read.
  4. [§6.1, footnote 1] The footnote discloses that the released activity tables for the Venmo cluster are incomplete and that their counts disagree; completing those tables from the raw trajectories should be part of the revision.
  5. [§1, Contribution (4)] The contribution list says 'two ground truths that share no machinery with each other,' which is accurate but easy to misread as claiming both are independent of the rule; consider rewording to note that the AppWorld reference is a self-consistency check sharing an assumption with the rule.

Circularity Check

2 steps flagged · score 6.0 of 10

AppWorld 0.993 precision is a self-consistency check by the paper's own admission: the replay-built reference and the rule share the same same-application-login assumption, so the precision partly measures the reference construction; the T1 main number honestly measures recency rather than exclusion, and the unique-candidate row is analytically forced.

  1. self definitional [Section 6.6 ('Token attribution on AppWorld'), paragraph 'This reference is not independent of the rule.']
    "This reference is not independent of the rule. Earlier versions described the construction as 'independent of any inference rule' and counted it as one of two independent ground truths. That is not defensible and we withdraw it. Replay must choose a value for each masked slot, and ours prefers a token produced by the consuming application's own authentication call. The reference is then built by matching those injected values back to their producers, while the rule under test attributes each token to the most recent same-application login. Injector, reference, and rule share an assumption."

    The AppWorld ground-truth edges are constructed by replaying trajectories and injecting masked token values using the same 'prefers a token produced by the consuming application's own authentication call' heuristic that the rule under test uses ('most recent same-application login'). The 563 reference edges are therefore not independent labels: the 0.993 precision mostly measures whether the rule agrees with the injection heuristic that created the reference. App-blind baselines in Table 5 are guaranteed to score lower because the reference was built with the same-application preference, so the comparison cannot validate the dependency rule's application-identity signal.

  2. self definitional [Section 6.5, discussion of Table 3 ('unique-candidate' row)]
    "The last row's precision of 1.000 is close to analytically forced rather than empirically earned: the call defining a variable never carries that variable in its own arguments, so it always survives the carrier exclusion, and when one candidate survives it is the definer. We name that row for what it computes — unique-candidate — rather than 'selective', because it emits a hard edge only when exactly one candidate survives, which with a mean of 8.2 survivors is a degenerate criterion and explains its recall of 0.071."

    The unique-candidate row's precision of 1.000 is a consequence of the construction: under the masking scheme, the producer of a variable never appears as a consumer of its own variable, so the single survivor of the carrier-exclusion filter is definitionally the producer. The score is a restatement of the exclusion/filter definition rather than independent evidence for the abstention mechanism; the paper's own wording ('analytically forced rather than empirically earned') concedes the reduction. It is a minor step because the paper does not build its central claim on this row and explicitly labels it a lower bound on abstention, but it is still a by-construction result presented in the evaluation.

full rationale

TraceCompiler's derivation chain is largely self-contained and unusually candid: the paper withdraws its earlier 'independent ground truth' claim, labels the AppWorld replay result a self-consistency check, and names the analytic forcing of the unique-candidate row. The main circular step is the AppWorld arm (Section 6.6), where the replay-built reference injects masked tokens using the same same-application-login assumption as the rule under test, so the reported 0.993 precision is partly a measure of the reference construction rather than of independent dependency recovery. A second, minor by-construction result is the Table 3 unique-candidate row, whose 1.000 precision is analytically forced by the masking and carrier-exclusion definitions. The T1 main evaluation is not circular in the same way: the def-use reference comes from template plans and the mechanized rule is a separate deterministic program, but the paper itself shows the 0.928 number measures 'most recent survivor' attribution under a nearly vacuous abstention branch and near-perfect token detection, so it supports a weaker claim than the advertised exclusion discipline. No load-bearing self-citations, imported uniqueness theorems, or ansatz-smuggling-via-citation were found. Overall, the circularity is partial and localized to the replay reference and an acknowledged degenerate ablation row; the central mechanism still has independent T1 content and is not forced by definition, so the score is 6 rather than higher.

Assumptions & free parameters 3 free parameters · 5 assumptions · 3 invented entities

The dependency rule itself is parameter-free, but the evaluation depends on domain assumptions: value-opaque trace structure, high-signal token presence on T1, single-agent generality, and deterministic replay. The free parameters are clustering defaults and a baseline threshold; the invented constructs are internal design elements without independent empirical support.

free parameters (3)
  • min_intra_cluster_similarity = 0.45
    Hand-chosen default for average-linkage cosine agglomeration in intent discovery (Section 5). Not tuned against labels; no sensitivity sweep reported. Affects the least-supported component, Section 6.4.
  • support_floor = 5
    Minimum cluster size for an intent to be compilable (Section 5). Hand-chosen default; clusters below the floor are set aside as not yet compilable.
  • recurrence_threshold_theta = 0.6
    Threshold for the RECURRENCE baseline in Table 2, swept over [0.1,0.9] and reported at best F1. A baseline parameter, not a parameter of the proposed method.
assumptions (5)
  • domain assumption Observational traces are evidence about task structure rather than one agent's habits.
    Section 7 flags this as unexamined: all AppWorld traces come from one ReAct agent and all T1 dialogues from one generator. If false, compiled workflows encode agent idiosyncrasy rather than task structure.
  • domain assumption A token's presence in an argument is an almost perfect dependency signal on T1.
    Section 6.5 shows all 22,975 consumption relations correspond to a true def-use edge at tool-pair granularity, making detection trivial and the evaluated task producer attribution. This corpus property is load-bearing for the T1 numbers.
  • domain assumption Dependencies can be inferred from the consumer side when outputs are unrecorded, because arguments carry concrete values or opaque co-references.
    Sections 2 and 3.3 define the value-opaque regime; the method depends on this premise, tested on T1 and AppWorld but not on traces where arguments are also masked or permissive.
  • domain assumption The AppWorld simulator is deterministic and replay faithfully reproduces real return values for successfully executed calls.
    Section 6.6 relies on replay to recover masked return values; 44.2% of non-documentation calls replay successfully, the rest fail for faithful reasons. Unfaithful replay would invalidate the 563-edge reference.
  • domain assumption The compiler skill, an LLM instruction package, is a capable agent that follows the specified procedure and can be frozen.
    Sections 4 and 5 rely on the skill's behavior; the freeze claim is acknowledged as testimony, and the executing model version was not recorded.
invented entities (3)
  • suspected dependency relation
    purpose: Marks edges for which a plausible alternative origin exists, so they impose no ordering constraint and only hard edges constrain the compiled DAG.
    Introduced in Section 3.3 as an abstention mechanism; an internal formal construct whose correctness is not independently falsifiable outside the paper's evaluation.
  • HUMAN node type
    purpose: Specified to be emitted when a node with an irreversible external effect has a binding the analysis cannot resolve to a provenance class, so proceeding would require guessing an unretractable value.
    Defined in Sections 2 and 3.5; the paper explicitly states no case study emits one and that it is a design element awaiting evidence.
  • evidence tuple
    purpose: Audit record attached to each hard edge, containing consumer, argument path, value, presumed producer, and exclusions, so a reviewer can trace any ordering constraint to concrete values.
    Introduced in Section 3.3; the paper does not release these tuples for the skill run, so the auditability property is not independently verifiable.

how reviews work

0 comments
Cite this review

Pith. "Pith review of TraceCompiler: Skill-Guided Mining and Compilation of LLM Agent Traces into Mostly Deterministic Workflows." pith.science (2026). https://pith.science/paper/3CNEMP6F

@misc{pith2026260802680,
  author       = {Pith},
  title        = {Pith review of: TraceCompiler: Skill-Guided Mining and Compilation of LLM Agent Traces into Mostly Deterministic Workflows},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/3CNEMP6F}},
  note         = {Machine review of arXiv:2608.02680}
}
read the original abstract

Tool-using language-model agents repeatedly rediscover procedures they have already executed, producing traces that mix reusable structure with retries, exploration, accidental ordering, and repeated lookups. We present TraceCompiler, a skill-guided system that mines clusters of noisy agent traces and compiles them into executable, mostly deterministic workflows. It admits an inter-tool dependency only when a consumer argument contains a value attributable uniquely to an earlier producer; every hard edge carries an auditable evidence tuple, and ambiguous relations are marked suspected and impose no ordering constraint. Bindings are classified as constants, user inputs, copied outputs, transforms, or residual LLM decisions. On T1, a mechanized form of the rule recovers producer-consumer dependencies at 0.928 precision and 0.943 recall over 15,775 def-use edges of its training split, against 0.711 F1 for adjacency and 0.712 for a frequency-thresholded directly-follows measure on identical data; the compiler skill run blind reaches 0.992 on 250 of those edges. On AppWorld we replay released trajectories in the deterministic simulator to recover masked return values and measure the rule against 563 token edges at 0.993 precision - a self-consistency check, since replay injects tokens by a related heuristic. We compile two recurring intents: a Venmo money-request intent reduces 34 observed API calls to 11 runtime calls and, under leave-one-out execution against the benchmark's own state tests, passes 15 of 21, the failing fold escalating rather than acting because its required branch was never observed; and a Spotify/Todoist intent the compiler correctly refuses to compile, because an irreversible side effect is under-determined. We measure call reduction but not offline compilation cost, so we claim no net efficiency result.

Figures

Figures reproduced from arXiv: 2608.02680 by the authors.

Figure 1
Figure 1. Overview. Multiple noisy executions of one intent (1) are grouped by behavioral clustering (2); denoising sepa [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Compiling the Venmo money-request intent (Ap [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Compiling the Spotify/Todoist intent (App [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Call reduction on open AppWorld traces (calls, [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

33 extracted references · 25 canonical work pages

  1. [1]

    RESTler: Stateful REST API fuzzing

    Vaggelis Atlidakis, Patrice Godefroid, and Marina Polishchuk. RESTler: Stateful REST API fuzzing. In Proceedings of the 41st International Conference on Software Engineering (ICSE), pages 748–758, 2019

    work page 2019

  2. [2]

    Process Mining Meets Causal Machine Learning: Discovering Causal Rules from Event Logs

    Zahra Dasht Bozorgi, Irene Teinemaa, Marlon Du- mas, Marcello La Rosa, and Artem Polyvyanyy. Pro- cess mining meets causal machine learning: Discov- ering causal rules from event logs. In2020 2nd In- ternational Conference on Process Mining (ICPM). IEEE, 2020. arXiv:2009.01561

    work page Pith review arXiv 2020

  3. [3]

    T1: A tool-oriented conversational dataset for multi-turn agentic planning

    Amartya Chakraborty, Paresh Dashore, Nadia Bathaee, Anmol Jain, Anirban Das, Shi-Xiong Zhang, Sambit Sahu, Milind Naphade, and Genta In- dra Winata. T1: A tool-oriented conversational dataset for multi-turn agentic planning. InAdvances in Neural Information Processing Systems 39: Datasets and Benchmarks Track, 2025

    work page 2025

  4. [4]

    Chasins, Maria Mueller, and Rastislav Bodík

    Sarah E. Chasins, Maria Mueller, and Rastislav Bodík. Rousillon: Scraping distributed hierarchical web data. InProceedings of the 31st Annual ACM Symposium on User Interface Software and Technol- ogy (UIST), pages 963–975, 2018

    work page 2018

  5. [5]

    SkillCraft: Can LLM agents learn to use tools skillfully?arXiv preprint arXiv:2603.00718, 2026

    Shiqi Chen, Jingze Gai, Ruochen Zhou, Jinghan Zhang, Tongyao Zhu, Junlong Li, Kangrui Wang, Zihan Wang, Zhengyu Chen, Klara Kaleb, Ning Miao, Siyang Gao, Cong Lu, Manling Li, Junx- ian He, and Yee Whye Teh. SkillCraft: Can LLM agents learn to use tools skillfully?arXiv preprint arXiv:2603.00718, 2026

    arXiv 2026

  6. [6]

    Agentic Compilation: Mitigating the LLM Rerun Crisis for Minimized-Inference-Cost Web Automation

    Jagadeesh Chundru. Agentic compilation: Mitigating the LLM rerun crisis for minimized-inference-cost web automation.arXiv preprint arXiv:2604.09718, 2026

    work page Pith review arXiv 2026

  7. [7]

    Massimiliano de Leoni and Wil M. P. van der Aalst. Data-aware process mining: Discovering decisions in 14 processes using alignments. InProceedings of the 28th Annual ACM Symposium on Applied Computing (SAC 2013), pages 1454–1461. ACM, 2013

    work page 2013

  8. [8]

    Memp: Exploring agent procedural memory

    Runnan Fang, Yuan Liang, Xiaobin Wang, Jialong Wu, Shuofei Qiao, Pengjun Xie, Fei Huang, Hua- jun Chen, and Ningyu Zhang. Memp: Exploring agent procedural memory. InFindings of the Asso- ciation for Computational Linguistics (ACL), 2026. arXiv:2508.06433

    arXiv 2026

Show all 33 references
  1. [9]

    Agentic AI process observability: Discovering be- havioral variability

    Fabiana Fournier, Lior Limonad, and Yuval David. Agentic AI process observability: Discovering be- havioral variability. InProceedings of the 4th In- ternational Workshop on Process Management in the AI Era (PMAI), co-located with ECAI, vol- ume 4087 ofCEUR Workshop Proceeding...

    2025

  2. [10]

    SKILL-DISCO: Distilling and compiling agent traces into reusable procedural skills

    Zhongxin Guo, Danrui Qi, Hanwen Gu, Peng Cheng, and Yongqiang Xiong. SKILL-DISCO: Distilling and compiling agent traces into reusable procedural skills. arXiv preprint arXiv:2606.26669, 2026

    2026 arXiv

  3. [11]

    Distilling LLM agent into small models with retrieval and code tools.arXiv preprint arXiv:2505.17612, 2025

    Minki Kang, Jongwon Jeong, Seanie Lee, Jaewoong Cho, and Sung Ju Hwang. Distilling LLM agent into small models with retrieval and code tools.arXiv preprint arXiv:2505.17612, 2025. NeurIPS 2025 Spotlight

    2025

  4. [12]

    Mahoney, Kurt Keutzer, and Amir Gholami

    Sehoon Kim, Suhong Moon, Ryan Tabrizi, Nicholas Lee, Michael W. Mahoney, Kurt Keutzer, and Amir Gholami. An LLM compiler for parallel function calling. InProceedings of the 41st International Conference on Machine Learning (ICML), 2024. arXiv:2312.04511

    2024 arXiv

  5. [13]

    PreAct: Computer-using agents that get faster on repeated tasks, 2026

    Bojie Li. PreAct: Computer-using agents that get faster on repeated tasks, 2026

    2026

  6. [14]

    Reijers, and Wil M

    Felix Mannhardt, Massimiliano de Leoni, Hajo A. Reijers, and Wil M. P. van der Aalst. Balanced multi- perspective checking of process conformance.Com- puting, 98(4):407–437, 2016

    2016

  7. [15]

    Hermes-Function-Calling- v1.https://huggingface.co/datasets/ NousResearch/hermes-function-calling-v1,

    Nous Research. Hermes-Function-Calling- v1.https://huggingface.co/datasets/ NousResearch/hermes-function-calling-v1,

  8. [16]

    Anne Rozinat and Wil M. P. van der Aalst. Decision mining in ProM. InBusiness Process Management (BPM 2006), volume 4102 ofLecture Notes in Com- puter Science, pages 420–425. Springer, 2006

    2006

  9. [17]

    Lifting traces to logic: Programmatic skill induc- tion with neuro-symbolic learning for long-horizon agentic tasks.arXiv preprint arXiv:2605.01293,

    Jie-Jing Shao, Haiyan Yin, Yueming Lyu, Xingrui Yu, Lan-Zhe Guo, Ivor Tsang, James Kwok, and Yu-Feng Li. Lifting traces to logic: Programmatic skill induc- tion with neuro-symbolic learning for long-horizon agentic tasks.arXiv preprint arXiv:2605.01293,

    arXiv

  10. [18]

    Process discovery using graph neural net- works

    Dominique Sommers, Vlado Menkovski, and Dirk Fahland. Process discovery using graph neural net- works. In2021 3rd International Conference on Pro- cess Mining (ICPM), pages 40–47. IEEE, 2021

    2021

  11. [19]

    AppWorld: Official reposi- tory and release disclaimer.https://github.com/ StonyBrookNLP/appworld, 2024

    Stony Brook NLP. AppWorld: Official reposi- tory and release disclaimer.https://github.com/ StonyBrookNLP/appworld, 2024. Accessed 2026- 07-28

    2024

  12. [20]

    Parallelizing tool execution and LLM generation for low-latency agent serving.arXiv preprint arXiv:2603.18897, 2026

    Yifan Sui, Han Zhao, Rui Ma, Zhiyuan He, Hao Wang, Jianxun Li, Kaiqiang Xu, Kai Chen, and Yuqing Yang. Parallelizing tool execution and LLM generation for low-latency agent serving.arXiv preprint arXiv:2603.18897, 2026

    2026 arXiv

  13. [21]

    Nikola Tr ˇcka, Wil M. P. van der Aalst, and Natalia Sidorova. Data-flow anti-patterns: Discovering data- flow errors in workflows. InAdvanced Information Systems Engineering (CAiSE), volume 5565 ofLec- ture Notes in Computer Science. Springer, 2009

    2009

  14. [22]

    AppWorld: A controllable world of apps and people for benchmarking interactive coding agents

    Harsh Trivedi, Tushar Khot, Mareike Hartmann, Ruskin Manku, Vinty Dong, Edward Li, Shashank Gupta, Ashish Sabharwal, and Niranjan Balasubra- manian. AppWorld: A controllable world of apps and people for benchmarking interactive coding agents. In Proceedings of the 62nd Annual ...

    2024

  15. [23]

    Wil M. P. van der Aalst.Process Mining: Data Sci- ence in Action. Springer Berlin Heidelberg, 2 edition, 2016

    2016

  16. [24]

    Wil M. P. van der Aalst and Alessandro Berti. Dis- covering object-centric Petri nets.Fundamenta Infor- maticae, 175(1–4):1–40, 2020

    2020

  17. [25]

    Agent workflow memory

    Zora Zhiruo Wang, Jiayuan Mao, Daniel Fried, and Graham Neubig. Agent workflow memory. InPro- ceedings of the 42nd International Conference on Machine Learning, volume 267 ofProceedings of Machine Learning Research, pages 63897–63911. PMLR, 2025

    2025

  18. [26]

    Work- flowGen: An adaptive workflow generation mecha- nism driven by trajectory experience.arXiv preprint arXiv:2604.19756, 2026

    Ruocan Wei, Shufeng Wang, and Ziwei Shi. Work- flowGen: An adaptive workflow generation mecha- nism driven by trajectory experience.arXiv preprint arXiv:2604.19756, 2026

    2026 arXiv

  19. [27]

    A. J. M. M. Weijters, Wil M. P. van der Aalst, and A. K. Alves de Medeiros. Process mining with the 15 HeuristicsMiner algorithm. BETA Working Paper Se- ries WP 166, Eindhoven University of Technology, 2006

    2006

  20. [28]

    Silva, and Juliana Freire

    Eden Wu, Sonia Castelo, Yurong Liu, Cláudio T. Silva, and Juliana Freire. AgentTrails: Towards trust and reuse for agentic tasks. InProceedings of the Workshop on Systems for Data-centric Agents with Human-in-the-loop (DASHSys), co-located with VLDB, 2026. arXiv:2607.18816

    2026 arXiv

  21. [29]

    ToolMind technical report: A large-scale, reasoning-enhanced tool-use dataset.arXiv preprint arXiv:2511.15718, 2025

    Chen Yang, Ran Le, Yun Xing, Zhenwei An, Zongchao Chen, Wayne Xin Zhao, Yang Song, and Tao Zhang. ToolMind technical report: A large-scale, reasoning-enhanced tool-use dataset.arXiv preprint arXiv:2511.15718, 2025

    2025

  22. [30]

    Speculative actions: A lossless framework for faster AI agents

    Naimeng Ye, Arnav Ahuja, Georgios Liargkovas, Yu- nan Lu, Kostis Kaffes, and Tianyi Peng. Speculative actions: A lossless framework for faster AI agents. In The Fourteenth International Conference on Learn- ing Representations (ICLR), 2026. Oral presentation; arXiv:2510.04371

    2026 arXiv

  23. [31]

    GRADE: Graph representation of LLM agent dependency and execution, 2026

    Yue Zhao. GRADE: Graph representation of LLM agent dependency and execution, 2026

    2026

  24. [32]

    Con- ditional hard

    Yuqing Zhou, Zhuoer Wang, Jie Yuan, Hong Wang, Samson Koelle, Ziwei Zhu, and Wei Niu. WISE- Flow: Workflow-induced structured experience for self-evolving conversational service agents.arXiv preprint arXiv:2601.08158, 2026. A The Compiler Skill (Condensed) The skill is a versi...

    2026

  25. [2024]

    Single-turn configuration func_calling_singleturn; accessed 2026-07-29

    2026

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.