juliensimon/agent-traces-customer-support-triage

Agent Traces: customer-support-triage

Synthetic multi-agent workflow traces with LLM-enriched content for the customer-support-triage domain.

Part of the juliensimon/open-agent-traces collection — 10 datasets covering diverse domains and workflow patterns.

What is this dataset?

This dataset contains 1,483 events across 50 workflow runs, each representing a complete multi-agent execution trace. Every trace includes:

• Agent reasoning — chain-of-thought for each agent step
• LLM prompts and completions — realistic request/response pairs
• Tool calls with inputs and outputs — structured JSON for each tool invocation
• Inter-agent messages — handoff content between workflow steps
• Deviation labels — ground-truth annotations for conformance checking

The content was generated using a two-pass architecture: structural OCEL 2.0 traces with configurable deviation injection, followed by LLM enrichment that fills in semantically coherent content across the entire workflow chain.

Domain: customer-support-triage

Customer support ticket triage: classify, research, and draft response

• Workflow pattern: sequential
• Runs: 50
• Noise rate: 0.2 (fraction of runs with injected deviations)
• Events: 1,483
• Objects: 859
• Seed: 1001 (reproducible)

Agents

Role	Persona
researcher	You are a support agent researching the customer's issue in the knowledge base and order management system
analyst	You are a support analyst determining the root cause, checking policies, and deciding the appropriate resolution
summarizer	You are a support agent drafting a clear, empathetic response to the customer with the resolution

Tools

Tool	Description
web_search	Search the internal knowledge base for policies, FAQs, and troubleshooting guides
file_reader	Read customer account details, order history, and previous support interactions
calculator	Calculate refund amounts, shipping costs, or discount values
code_interpreter	Run queries against the order management database

Schema

Each row represents one event in the OCEL 2.0 trace. Events are linked to runs, agents, LLM calls, tool calls, and messages through denormalized columns.

Column	Type	Description
event_id	string	Unique event identifier (e.g. run-0012-evt-0003)
event_type	string	One of: run_started, agent_invoked, llm_request_sent, llm_response_received, tool_called, tool_returned, message_sent, routing_decided, agent_completed, run_completed, error_occurred, retry_started
timestamp	string	ISO 8601 timestamp with realistic inter-event durations
run_id	string	Which workflow run this event belongs to
sequence_number	int	Monotonic order within the run
is_deviation	bool	Whether this event is part of an injected deviation
deviation_type	string	Type of deviation: skipped_activity, inserted_activity, wrong_resource, swapped_order, wrong_tool, repeated_activity, timeout, wrong_routing, missing_handoff, extra_llm_call
step_id	string	Workflow step identifier (e.g. research, analyze)
agent_role	string	Role of the agent handling this event
model_name	string	LLM model used (e.g. gpt-4o, claude-3-5-sonnet)
prompt	string	LLM prompt text (enriched, on llm_response_received events)
completion	string	LLM completion text (enriched)
tool_name	string	Name of the tool called
tool_input	string	Tool input as JSON (enriched)
tool_output	string	Tool output as JSON (enriched)
message_content	string	Inter-agent handoff message content (enriched)
reasoning	string	Agent chain-of-thought reasoning (enriched)
input_tokens	int	Input token count (calibrated to content length)
output_tokens	int	Output token count (calibrated to content length)
latency_ms	int	LLM or tool call latency in milliseconds
cost_usd	float	Estimated cost of the agent invocation
is_conformant	bool	Whether the run follows the expected workflow
pattern	string	Workflow pattern: sequential, supervisor, or parallel
domain	string	Domain name: customer-support-triage
user_query	string	The user request that initiated the workflow run

Usage

from datasets import load_dataset

ds = load_dataset("juliensimon/agent-traces-customer-support-triage")

# Browse a single run
run_0 = [row for row in ds["train"] if row["run_id"] == "run-0000"]
for event in run_0:
    print(f"{event['event_type']:25s} | {event['agent_role']:12s} | {event['reasoning'][:60] if event['reasoning'] else ''}")

# Get all LLM completions
completions = ds["train"].filter(lambda x: x["event_type"] == "llm_response_received")
for row in completions:
    print(f"Prompt: {row['prompt'][:80]}...")
    print(f"Completion: {row['completion'][:80]}...")
    print()

# Analyze deviations
deviant_runs = ds["train"].filter(lambda x: not x["is_conformant"])
deviant_events = ds["train"].filter(lambda x: x["is_deviation"])
print(f"Deviant runs: {len(set(deviant_runs['run_id']))}")
print(f"Deviation types: {set(e for e in deviant_events['deviation_type'] if e)}")

# Extract tool call patterns
tool_events = ds["train"].filter(lambda x: x["event_type"] == "tool_called")
for row in tool_events:
    print(f"{row['tool_name']}: {row['tool_input'][:80]}")

Use cases

• Agent observability tooling — build and test dashboards that visualize multi-agent workflows
• Process mining — apply OCEL 2.0 conformance checking algorithms to detect workflow anomalies
• Anomaly detection — train classifiers to distinguish conformant from deviant agent behavior
• Agent evaluation — benchmark agent reasoning quality across domains and patterns
• Trace analysis — study how information flows between agents in different workflow patterns

Files

File	Format	Description
data/train.parquet	Parquet	Flat tabular format (one row per event) — use with datasets
ocel/output.jsonocel	OCEL 2.0 JSON	Native OCEL format with full object-centric event log
ocel/normative_model.json	JSON	Expected workflow template for conformance checking
ocel/manifest.json	JSON	Generation metadata, deviation ground truth

How it was generated

Generated with ocelgen using a two-pass architecture:

1. Structural generation — OCEL 2.0 compliant traces with configurable workflow patterns (sequential, supervisor, parallel), deviation injection, and reproducible seeding
2. LLM enrichment — each agent step is enriched via OpenRouter with domain-specific prompts, producing coherent chains where each agent's output feeds into the next agent's context

Quality improvements applied:

• Token counts calibrated to actual content length (1.3x word-to-token ratio)
• Realistic timestamps (seconds-scale LLM latencies, not milliseconds)
• 50 unique user queries per dataset (LLM-expanded from seed queries)
• Deviation-aware enrichment (deviant steps generate failure-reflecting content)
• Parallel aggregator coherence (aggregator sees all parallel workers' outputs)

Citation

If you use this dataset in your research, please cite:

@misc{ocelgen-customer-support-triage,
  title={Agent Traces: customer-support-triage},
  author={Julien Simon},
  year={2026},
  publisher={Hugging Face},
  url={https://huggingface.co/datasets/juliensimon/agent-traces-customer-support-triage}
}

License

MIT — see https://github.com/juliensimon/ocel-generator for the generator source code.