README.md

---
dataset_info:
  features:
    - name: event_id
      dtype: string
    - name: event_type
      dtype: string
    - name: timestamp
      dtype: string
    - name: run_id
      dtype: string
    - name: sequence_number
      dtype: int64
    - name: is_deviation
      dtype: bool
    - name: deviation_type
      dtype: string
    - name: step_id
      dtype: string
    - name: agent_role
      dtype: string
    - name: model_name
      dtype: string
    - name: prompt
      dtype: string
    - name: completion
      dtype: string
    - name: tool_name
      dtype: string
    - name: tool_input
      dtype: string
    - name: tool_output
      dtype: string
    - name: message_content
      dtype: string
    - name: reasoning
      dtype: string
    - name: input_tokens
      dtype: int64
    - name: output_tokens
      dtype: int64
    - name: latency_ms
      dtype: int64
    - name: cost_usd
      dtype: float64
    - name: is_conformant
      dtype: bool
    - name: pattern
      dtype: string
    - name: domain
      dtype: string
    - name: user_query
      dtype: string
  splits:
    - name: train
      num_examples: 2033
license: mit
tags:
  - agent-traces
  - ocel
  - multi-agent
  - process-mining
  - synthetic
  - llm-agents
  - conformance-checking
size_categories:
  - 1K<n<10K
---

# Agent Traces: data-pipeline-debugging

**Synthetic multi-agent workflow traces with LLM-enriched content** for the **data-pipeline-debugging** domain.

Part of the [juliensimon/open-agent-traces](https://huggingface.co/collections/juliensimon/open-agent-traces) collection — 10 datasets covering diverse domains and workflow patterns.

## What is this dataset?

This dataset contains **2,033 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: data-pipeline-debugging

Data pipeline debugging: supervisor routes to log analyzer, schema checker, and fix proposer

- **Workflow pattern:** `supervisor`
- **Runs:** 50
- **Noise rate:** 0.25 (fraction of runs with injected deviations)
- **Events:** 2,033
- **Objects:** 1,116
- **Seed:** 5005 (reproducible)

### Agents

| Role | Persona |
|------|---------|
| `supervisor` | You are a data engineering lead triaging a pipeline incident and assigning investigation tasks to specialists |
| `researcher` | You are a log analyst examining execution logs, error traces, and resource utilization metrics |
| `coder` | You are a schema and data quality checker validating data shapes, types, and integrity constraints |
| `reviewer` | You are a fix proposer suggesting configuration changes, code patches, or architectural improvements |

### Tools

| Tool | Description |
|------|-------------|
| `web_search` | Search internal runbooks and documentation for known issues and fixes |
| `file_reader` | Read pipeline configuration files, DAG definitions, and dbt models |
| `code_interpreter` | Run diagnostic queries against the data warehouse and metadata store |
| `database_query` | Query pipeline execution logs and monitoring metrics |

## 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: `data-pipeline-debugging` |
| `user_query` | string | The user request that initiated the workflow run |

## Usage

```python
from datasets import load_dataset

ds = load_dataset("juliensimon/agent-traces-data-pipeline-debugging")

# 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](https://github.com/juliensimon/ocel-generator)** 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:

```bibtex
@misc{ocelgen-data-pipeline-debugging,
  title={Agent Traces: data-pipeline-debugging},
  author={Julien Simon},
  year={2026},
  publisher={Hugging Face},
  url={https://huggingface.co/datasets/juliensimon/agent-traces-data-pipeline-debugging}
}
```

## License

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