--- language: - en pretty_name: CrossSearch (100-task paper set) configs: - config_name: tasks data_files: tasks.jsonl.gz --- # CrossSearch: 100-task paper set This resource contains 100 tasks and 4,269 selected, completed evaluation runs: 3,000 native-search runs (10 model configurations, three final attempts per task) and 1,269 search-backend ablation runs (three models, 47 shared tasks, three alternative backends, three attempts). The 600 Opus 5.5/GPT-6.1 Sol runs are included in the 3,000. ## Files - tasks.jsonl.gz: expert questions, frozen rubrics and evidence maps. - tasks.tar.gz: starting workspace assets, separated from grader-only reference material. - rollouts-*.jsonl.gz: saved agent trace files, API request/response captures, final answers, original rewards and criterion judgments. The 669 encrypted source runs are exported as readable derivatives. Source archives remain unchanged; no private key is distributed. - run-index.jsonl.gz: a compact lookup of all run IDs, tasks, models, conditions, rewards and the shard holding each trajectory. - judge-models.csv: one row for each of the 415 audited encrypted extension records, with evidence references and recorded judge labels. - CrossSearch-Judge-Prompt.txt and CrossSearch-Agent-Prompt.txt: appendix prompt templates, message roles and source notes. - grading-protocol.md: scoring protocol and judge-version uncertainty. - judge-model-audit.json: recorded judge fields for the 415 encrypted extension records. - analysis-summary.json: frozen paper/blog results. - release-manifest.json: final counts, shard checksums, redaction totals and verification status. Check this manifest for completeness. ## Reading the data from datasets import load_dataset tasks = load_dataset('AfterQuery/CrossSearch', 'tasks', split='train') Read rollout files directly with the standard-library recipe below. The complete saved traces can be much larger and more heterogeneous than a tabular dataset preview. Each rollout retains the original archive hash and source-member hashes. Operational credentials and local author/account paths are removed from publication derivatives. Available reasoning text is retained apart from credential and local-path removals; opaque provider reasoning cannot be converted to visible thoughts. Per-run trace files preserve evaluated prompt wrappers. Native and ablation conditions remain separate; valid low and zero rewards are included. The evaluation uses three final, complete attempts per task and model/search configuration. Some targets required additional fresh attempts when an earlier attempt did not provide complete answer, reward and rubric-judgment evidence. Those incomplete attempts remain separate from the selected runs in this release. No model was called and no answer was regraded to create this resource. For a direct read without a dataset framework, download a rollout shard and use Python's standard library: import gzip, json with gzip.open('rollouts-00000.jsonl.gz', 'rt', encoding='utf-8') as f: run = json.loads(next(f)) print(run['model'], run['reward'], run['answer']) judgments = json.loads(run['rubric_judgment']) `trace_files` contains the saved text traces. A `duplicate_of` entry points to the identical earlier member in that same run. `binary_files` retains image and other binary bytes as base64, with their original hashes. Some exceptionally large traces use `large_record_parts`. Their normal rollout row still contains the answer, reward and rubric judgments. The ordered `.txt.gz` parts reconstruct the full original publication record, including all trace and binary members; no conversation log is omitted to meet a temporary storage limit. Reassemble before inspecting `trace_files`: import gzip, hashlib, json, urllib.request base = 'https://huggingface.co/datasets/AfterQuery/CrossSearch/resolve/main/' if run.get('large_record_parts'): pieces = [] for part in sorted(run['large_record_parts'], key=lambda x: x['part']): packed = urllib.request.urlopen(base + part['name']).read() assert hashlib.sha256(packed).hexdigest() == part['sha256'] piece = gzip.decompress(packed) assert hashlib.sha256(piece).hexdigest() == part['payload_part_sha256'] pieces.append(piece) payload = b''.join(pieces) assert hashlib.sha256(payload).hexdigest() == run['large_record_sha256'] run = json.loads(payload)