Agent Miner Procedure: Multi-Agent Process Discovery

• Agent Miner Procedure is an algorithmic framework that extracts modular, interpretable multi-agent process models from structured and unstructured data.
• It partitions event logs by agent identity and applies specialized techniques to derive detailed interaction nets and agent-specific workflows.
• The approach supports automated troubleshooting, agent discovery, and training of GUI agents by converting technical documents into actionable procedural datasets.

Agent Miner Procedure refers to algorithmic methodologies for discovering, extracting, or generating process models, agent systems, or actionable datasets by analyzing structured or unstructured data. The term encompasses a spectrum of procedures, from mining multi-agent process models from event data, to extracting and structuring stepwise procedures from technical support documents, to generating intent–trajectory pairs for training GUI agents. Representative approaches include the “Agent Miner” algorithm for agent system discovery from event logs, the Agent Miner Procedure for troubleshooting instruction extraction, and advanced agent-mining systems for data-rich reinforcement learning domains.

1. Conceptual Foundations and Motivation

Agent Miner Procedures arise in response to the limitations of conventional process discovery and automated data mining in multi-agent environments. Traditional control-flow models (e.g., Petri nets/bpmn) derived from monolithic event logs often result in highly complex "spaghetti models" that make the analysis of individual agents and their interactions intractable. The Agent Miner paradigm advocates partitioning data along agent lines, thus reconstructing modular models that explicitly represent both the behavior of individual agents and their protocols of interaction. The resulting models are more interpretable and often yield higher-fidelity representations of observed systems (Tour et al., 2022).

In the context of technical documentation, Agent Miner Procedures automate the extraction and structuring of complex, branching troubleshooting protocols, enabling dialog agents or process automation to operate on procedural knowledge mined at scale (Gupta et al., 2018).

2. Inputs, Outputs, and Core Artifacts

Agent Miner Procedures operate on diverse data forms:

• Event selection $S$: A temporally ordered, often case-labeled, set of events with attributes (e.g., timestamp, agent, activity) (Tour et al., 2022).
• HTML technical documents: Structured lists and sections containing procedures and decision points (Gupta et al., 2018).
• High-level domains: Intent specifications and observations in GUI or software agent domains.

Typical outputs include:

• Interaction nets (i-nets): Workflow nets where transitions are labeled by agent types plus silent ($\tau$) transitions, capturing handover between agents.
• Agent nets: Workflow nets per agent, modeling intra-agent control-flow.
• Fused MAS nets: Modular workflow nets unifying agent and interaction protocols.
• Structured procedures: Hierarchical breakdowns of procedural steps, decision points, and mappings for execution (Gupta et al., 2018).

3. Algorithmic Pipeline and Formalism

Agent Miner Procedures are defined via modular pipelines. The following strictly describes the pipelines as reported in key sources.

Dividing Event Logs into Agent System Models (Tour et al., 2022)

1. Agent Trace Set Creation: Partition $S$ into maximal contiguous subsequences where agent and case are constant, not interrupted by another agent's event in the same case.
2. Interaction Log Construction: Extract first events from each agent trace; group by case to form $L_I$.
3. Interaction Net Discovery: Apply an Interaction Net Discovery Algorithm (INDA, e.g., Inductive Miner) to $L_I$ yielding i-net $N_I$.
4. Agent Log Formation: For each agent type $a$, extract all events with agent $= a$, constructing $L_a$.
5. Agent Net Discovery: Apply Agent Net Discovery Algorithm (ANDA, e.g., DFG-PN translation) to $L_a$.
6. MAS Net Assembly: For each observable $\tau$0 in $\tau$1, refine it by the corresponding agent net $\tau$2 and eliminate series places via Murata’s fusion rule.

Pseudocode:

$S$0 See (Tour et al., 2022) for detailed subroutines and mathematical definitions.

Structured Extraction from Technical Documents (Gupta et al., 2018)

1. Procedure Extraction: Use an SVM classifier on HTML lists with tf-idf, context, list-type, and imperative-verb features to identify candidate procedures.
2. Decision-Point Identification: Apply rules using slot-grammar parses to identify and extract if/when…then… splits.
3. Decision-Block Segmentation: Sequential rules define the subsequence of instructions contingent on each decision point, stopping at key discourse or structure cues.
4. Instruction-to-Decision Mapping: Assign sentences to True/False branches based on local cues (else/otherwise) and similarity of nested conditionals.

Pipeline Table

Phase	Input	Key Technique/Algorithm
Procedure Extraction	HTML list	SVM classifier
Decision-Point Identification	Candidate step sentence	Slot-grammar parser
Decision-Block Segmentation	Procedure + step index	Rule-based segmentation
Instruction Mapping	Instruction, condition pairs	Branch mapping rules

4. Data Structures, Mathematical Objects, and Complexity

Key mathematical constructs include:

• Petri nets: $\tau$3 encoding places, transitions, arcs, transition labels, and labeling function.
• Traces and logs: Sequences of events partitioned by agent and case, with grouping/equivalence relations explicitly defined.
• Distance metric for agent-type clustering: For $\tau$4, the measure $\tau$5 quantifies behavior similarity via directly follows graphs.
• Mapping functions: Decision mapping functions $\tau$6, similarity measures for nested condition alignment, and formal BOW-based or grammar-based features.

Computational complexity is dominated by process discovery invocations:

• ANDA: $\tau$7 per agent.
• INDA: Polynomial in $\tau$8.
• Overall: $\tau$9 (Tour et al., 2022).

5. Empirical Evaluation and Benchmarks

Agent Miner Procedures undergo quantitative evaluation via:

• Model quality (MAS nets vs monolithic nets): Precision and recall via entropy-based measures [Polyvyanyy et al. 2020], model size (#nodes + #arcs), and Pareto front analysis (Tour et al., 2022).
• Segmentation/mapping accuracy: Decision-Block segmentation accuracy up to 90%, decision-point extraction precision 0.96, recall 0.86, procedure extraction F1 0.90 (Gupta et al., 2018).
• Real-world datasets: Publicly available BPIC logs and large annotated HTML corpora for empirical validation.

Empirical results indicate that modular, agent-aware models are at least as precise and often more interpretable than conventional monolithic models, with clearer representation of collaboration and agent responsibilities (Tour et al., 2022).

6. Strengths, Limitations, and Extensions

Strengths

• Modularity: Yields per-agent behavioral models and explicit interaction protocols, improving interpretability.
• Scalability: Complexity of individual agent nets does not necessarily increase with global data size.
• Faithfulness to observed behavior: More accurate reflection of multi-agent or collaborative processes.
• Structured outputs: Enables direct use in dialog agents, robotic process automation, or verification tasks (Gupta et al., 2018).

Limitations

• Agent granularity: One-to-one mapping of events to agents; extension to multi-party or ambiguous attributions requires future research.
• Temporal assumptions: Utilizes only the first event as interaction-initiator; more nuanced duration/lifecycle semantics are omitted in the canonical procedure (Tour et al., 2022).
• Discourse and markup dependence: Accuracy may drop in non-HTML sources or if markup is degraded (e.g., PDF conversion) (Gupta et al., 2018).

Future Directions

• Lifecycle- and queue-mining: Integration of event lifecycles and inter-agent queueing.
• Agent-specific quality metrics: Development of measures beyond control-flow criteria for richer analysis.
• End-to-end neural sequence modeling: Sequence tagging and joint procedure modeling for less-structured source texts.

7. Applications and Impact

Agent Miner Procedures are applied in:

• Multi-agent system identification: Decomposition and modeling of complex event logs in business process mining.
• Automated generation of action datasets: Construction of GUI agent behavior datasets for intelligent HCI via multi-agent MCTS (Lv et al., 5 Feb 2026).
• Conversational agents and RPA: Extraction of structured troubleshooting flows for chatbot or robotic process automation, enabling guided diagnostic dialog (Gupta et al., 2018).
• Domain-specific scientific exploration: Decomposition of multimodal data in mineral exploration using hierarchical agent modules (Yu et al., 2024).

These approaches have demonstrated superior data quality, interpretability, and efficiency in both industrial process mining and intelligent agent dataset generation, with formal guarantees on modularity and soundness under standard modeling assumptions (Tour et al., 2022).