Raw trajectories of an in-house DOM-based, tool-calling web agent, recorded while it ran public web-agent benchmarks on one host (2026-09 – 2026-10). This repo holds judged sessions that are not in the success set: judged failures, plus sessions judged successful that did not finish normally (success=true, completed=false). The sibling repo lukakuma/web-trajectories holds the success set.

Every LLM call is stored exactly as the agent model received and produced it: the full messages list, the tool definitions and the response blocks. Nothing is summarised or reformatted; the only edit is the scrub listed under Caveats.

source (split)	origin	license	sessions	tasks	LLM calls
`om2w`	Online-Mind2Web	CC-BY-4.0	4,731	271	229,569
`webvoyager`	WebVoyager	Apache-2.0	363	81	15,470
`webbench`	WebBench	MIT	401	116	20,232
`canvas`	In-house canvas tasks (Korean instructions)	CC-BY-4.0	445	95	15,626
`mind2web2`	Mind2Web 2 (dev set)	CC-BY-4.0	20	6	1,428
total			5,960	569	282,325

Agent models: Qwen3.8-Flash-Next 3,880, Qwen3.8-27B 1,533, Qwen/Qwen3.6-27B-FP8 464, claude-opus-5-5 55, claude-sonnet-5-5 19, Qwen3.6-27B 9. Instructions are English except canvas (Korean).

Layout

Three configs; splits are sources, not train/test (no held-out split has been made).

config	one row per	join key
`sessions` (default)	session (one agent run on one task)	`session_id`
`turns`	LLM call inside a session, in order	`session_id`, `turn_index`
`tools`	distinct tool-definition list	`tools_hash`

from datasets import load_dataset

sessions = load_dataset("lukakuma/web-trajectories-fail", "sessions", split="om2w")
turns = load_dataset("lukakuma/web-trajectories-fail", "turns", split="om2w")
tools = load_dataset("lukakuma/web-trajectories-fail", "tools", split="train")

# one training example per call: input = messages (+ tools), target = response
import json
t = turns[0]
messages, response = json.loads(t["messages"]), json.loads(t["response"])

`sessions`

column	type	meaning
`session_id`	str	content fingerprint of the session's call log (duplicate copies on disk collapse to one row)
`source`, `task_id`	str	benchmark and its original task id (kept as the original string)
`rep`, `run`	int, str	repetition number and the benchmark run the session came from
`goal`, `start_url`, `domain`, `category`	str	instruction, start page, site, original stratum (om2w level, WebVoyager site, WebBench type)
`language`, `license`	str	instruction language; license of the source benchmark
`success`	bool	benchmark judge verdict (not the agent's self-report)
`completed`	bool	exit code 0, no timeout, not blocked
`judge_model`, `judge_mode`, `judge_prompt_version`, `judge_reason`	str	who judged, how, with which prompt version, and the judge's stated reason
`task_n_judged`, `task_n_success`	int	over all judged sessions of the same task on this host (a rough per-task pass rate)
`self_reported_success`	bool	the agent's own claim, for reference only
`agent_model`, `mode`, `harness_version`, `agent_version`, `git_head`, `src_tree`	str	version stamp of the agent and code
`system_prompt_hash`, `tools_hash`, `browser_arm`, `started_at`	str	prompt / tool-set version, browser setup, start time
`n_llm_calls`, `n_act_turns`, `calls_by_purpose`	int, int, json	call counts (act / goal decomposition / plan tools / completion check …)
`in_tokens`, `out_tokens`, `max_turn_in_tokens`	int	token totals (agent tokenizer) and the longest single input
`wall_s`, `llm_s`, `tool_s`	float	wall time, time in LLM calls, time in tools
`n_compactions`	int	how many times older observations were rewritten (see Turn format)
`final_report`, `final_url`	str	the agent's final report text and last page URL
`copies_on_disk`	int	identical copies found (e.g. rescoring runs copy sessions)

`turns`

column	type	meaning
`session_id`, `turn_index`, `step`, `ts`	str, int, int, str	order inside the session
`purpose`	str	`act`, `decompose_goal`, `plan_tool:*`, `completion_verify`, `text_only` …; null when the session has no purpose log
`model`	str	model that served the call
`messages`	json str	the exact input of the call (OpenAI-style list incl. system prompt and tool results)
`tools_hash`	str	tool definitions offered on this call (→ `tools`); null for calls without tools
`response`	json str	the exact output blocks (`text`, `tool_call` with `name` and JSON `input`)
`in_tokens`, `out_tokens`, `cache_tokens`, `latency_s`	int, float	per-call usage
`extends_previous`	bool	this input = previous tool-bearing input (minus its trailing hint) + new messages
`action_ok`	bool	every tool call of this turn returned success (false if any failed; null if unknown)

`tools`

tools_hash, n_tools, tool_names, tools (the JSON list exactly as sent).

Turn format

Each call's messages repeats the conversation so far. About 95% of tool-bearing calls extend the previous input exactly (extends_previous=true), so consecutive turns can be packed into one sequence.
The last message of most inputs is a one-off <system-hint> user message; it is dropped from the next input.
When a newer observation arrives, older tool results are rewritten to a short stub ([관측 축약: 최신 관측으로 대체됨 — url=…], Korean for “observation shortened: replaced by the latest one”). These rewrites break the prefix and are counted in n_compactions.
Inputs are long: in the success set the per-call input median is about 26k tokens, p95 about 40k, max about 107k (agent tokenizer). Inputs are text only (DOM observations); screenshots are not part of the model input and are not included.

How the data was selected

Every folder with a call log under the host's benchmark and console output directories was scanned.
Copies of the same session (identical call log) were collapsed; the most recent judgment wins.
Quarantined runs (_VOID_), sessions without a judgment, judge errors and BrowseComp (every row carries a canary: “BENCHMARK DATA SHOULD NEVER APPEAR AS PLAIN TEXT ONLINE”) were dropped.
Success set = success and completed; everything else judged goes to the fail repo.

Caveats

Single judge. Each verdict comes from one benchmark judge run (mostly Qwen3.8-27B); nothing was re-judged. Where the same session was judged twice the verdicts agreed 96.8% of the time (2,968 sessions). Successes on tasks with a low task_n_success / task_n_judged are more likely to be judge errors.
No held-out split. Tasks come from public benchmarks; a model trained on this data cannot be evaluated fairly on the same tasks.
Uneven per-task counts. Some Online-Mind2Web tasks have 50+ sessions, others one. Sample per task for diversity.
Mixed versions. Several system-prompt and tool-list versions over the period; filter with the version columns.
Model outputs, not gold labels. Successful sessions still contain failed actions, retries and loops (action_ok).
Korean instructions only in canvas.
Scrub. Local session paths inside tool results were replaced with <session>/…, other local paths with <path>, the home directory with ~, internal product identifiers with agent, and test-account secrets with [REDACTED]. A scan for private IPs, API keys, tokens and JWTs found nothing. E-mail addresses that appear are text of the public pages visited.
Third-party page text. Observations contain text of the visited public websites as of the run date.

Licenses and attribution

Each row carries the license of its source benchmark (license). Please cite the original benchmarks: Online-Mind2Web (Xue et al., 2025, arXiv:2504.01382), WebVoyager (He et al., 2024), WebBench (Halluminate), Mind2Web 2 (Gou et al., 2025, arXiv:2506.21506). Online-Mind2Web states it was released for research purposes.