ZhuofengLi/Harbor-SWE-Trajectory

Harbor SWE Trajectory

Harbor SWE-bench Verified mini job outputs from Qwen3, Qwen3.5, and Claude Sonnet 4.6 runs. Subsets distinguish models and, for Sonnet, the solving harness. Each row represents one captured trial. Historical Qwen job exports and the Sonnet direct-solving subsets use test; the separately audited Qwen n=16 subsets use train. These split names label benchmark execution records and do not imply a new train/test partition.

Contents

Subset	Actual model	Job sources	Trial records	Trajectories
Qwen3-14B	Qwen/Qwen3-14B	3	66	60
Qwen3-30B-A3B	Qwen/Qwen3-30B-A3B	3	107	55
Qwen3-4B	Qwen/Qwen3-4B	4	96	56
Qwen3-8B	Qwen/Qwen3-8B	3	52	52
Qwen3.5-27B	Qwen/Qwen3.5-27B	2	51	51
Qwen3.5-35B-A3B	Qwen/Qwen3.5-35B-A3B	1	50	50
Qwen3.5-4B	Qwen/Qwen3.5-4B	3	96	92
SWE-Lego-Qwen3-8B	Lego-X/SWE-Lego-Qwen3-8B	5	106	104
Sonnet-4.6-Agentless-Mini	anthropic/claude-sonnet-4-6	1	50	50
Sonnet-4.6-OpenHands	anthropic/claude-sonnet-4-6	1	50	50

Load

import json
from datasets import load_dataset

trials = load_dataset(
    "ZhuofengLi/Harbor-SWE-Trajectory", "Qwen3.5-4B", split="test", token=True
)
for trial in trials:
    if trial["has_trajectory"] and not trial["trajectory_parse_error"]:
        trajectory = json.loads(trial["trajectory"])
        print(trial["job_name"], trial["task_name"], len(trajectory["steps"]))
        break

trajectory contains the complete original ATIF JSON as a string. This preserves heterogeneous tool-call and observation structures across agent versions. trial_config, trial_result, job_config, and job_result are also JSON strings. Missing results are represented by the JSON string null; missing trajectories are null values. Scalar columns expose the model, agent, task, job, trial, reward, exception type, status, token counts, and number of steps for filtering.

Job log archives

raw/<subset>/<job>--<source-hash>.tar.gz preserves the log paths within each source job directory, including configurations, results, trajectories, terminal recordings, completion logs, verifier reports, and generated patches. Only text log and metadata formats are included. Model weights, workspace archives, Python/shell scripts, binary session state, lock files, and the artifacts directory are excluded. Each job manifest lists the excluded non-log paths. The source hash distinguishes historical snapshots with the same job name. raw_archive and raw_trial_path locate the logs for each row.

manifests/jobs.jsonl records every captured job source, its original relative path, snapshot interval, file count, trial counts, and archive SHA-256. manifests/files.jsonl records every archived file and its SHA-256 (or symlink target). checksums.sha256 indexes the original log export and this Sonnet addition; the later Qwen n=16 artifacts also provide their own checksum files.

Historical Qwen snapshot: scope and interpretation

• Includes every locally executed Qwen job found under the experiment's runs directory, including logs from preflight jobs, failure records, recovery archives, SWE-Lego runs, and the available SWE-Review run.
• Recovery archives are historical partial snapshots of jobs, not independent benchmark runs. Trials can recur in a current job and its recovery archive. source_job_path and record_id distinguish them. Do not aggregate all rows as a benchmark score or deduplicate only by task name.
• status describes the captured trial: completed means a result has a finish time without an exception; error means exception information is present; incomplete means completion was not recorded. Completion does not imply reward 1. Missing trajectories are retained as rows, including setup failures.
• Original job summaries may describe more trials than are physically present in a recovery directory. Captured counts come from actual archived trial files.
• SWE-Review was running during capture. Its directory is an interval snapshot; files and trials produced after capture are not included. Missing finish times on older jobs can also reflect interrupted runs. No running jobs were stopped.
• SWE-Lego-Qwen3-8B uses Lego-X/SWE-Lego-Qwen3-8B weights. Its serving alias is Qwen/Qwen3-8B; it is kept separate from the official Qwen3-8B subset. This mapping is documented in the local experiment's SWE-LEGO.md.
• The historical Qwen3.5-9B run documented on another H100 machine is not available locally and is outside this local-only upload.
• High-confidence credential patterns in text artifacts are replaced with [REDACTED_CREDENTIAL] if found. Counts are recorded in each job manifest.
• Artifacts retain source benchmark and repository contents and their applicable upstream licenses. This card does not assign a new license to those contents.

Snapshot started at 2026-09-07T21:38:36.396177+00:00 (UTC). Per-job intervals are recorded in the manifest.

---

Fully audited n=16 runs: Qwen3.5-4B and Qwen3.5-9B

This dataset contains the complete preserved Harbor-SWE run for the 50 tasks in examples/swebench-verified-mini: 16 attempts per task and 800 attempts per model. The two model sizes are separate Hugging Face dataset subsets: qwen3.5-4b and qwen3.5-9b.

Subset	Pass@1	Pass@2	Pass@4	Pass@8	Pass@16	Tasks solved	Resolved attempts	Scored attempts	Unscored
qwen3.5-4b	37.75%	47.97%	55.75%	59.78%	62.00%	31/50	302/800 (37.75%)	796	4
qwen3.5-9b	49.00%	57.77%	64.35%	69.02%	74.00%	37/50	392/800 (49.00%)	795	5

Pass@k is averaged over the 50 tasks using the standard unbiased estimator 1 - C(n-c, k) / C(n, k), where n=16 and c is the number of resolved attempts for that task. Pass@16 is therefore the fraction of tasks solved at least once. Resolved attempts is an attempt-level diagnostic, not a Pass@k score. Null rewards remain part of the 16 collected samples and count as unsuccessful for Pass@k, while remaining distinct from reward 0 in the data.

Each JSONL row is a compact index. The corresponding archive contains original ATIF trajectories, terminal recordings, command request/results, raw and Harbor-normalized API records, patches, verifier output, frozen configuration, recovery evidence, audits, and SHA-256 manifests. archive_member points to the trial directory inside the archive.

• qwen3.5-4b: 5 model-induced terminal exits were graded from the unchanged captured patch; 0 agent timeouts kept their original verifier score; 2 verifier-only timeouts, 0 combined agent/verifier timeout, and 2 local task-RPC failure(s) remain unscored.
• qwen3.5-9b: 0 model-induced terminal exits were graded from the unchanged captured patch; 3 agent timeouts kept their original verifier score; 3 verifier-only timeouts, 1 combined agent/verifier timeout, and 1 local task-RPC failure(s) remain unscored.

The raw API log also preserves handled retries:

• qwen3.5-4b raw model-API records contain 419 HTTP 400 context-limit responses and 2 transient disconnect/reset responses. Harbor handled these through summarization or retry, and the affected logical trials continued.
• qwen3.5-9b raw model-API records contain 595 HTTP 400 context-limit responses and 7 transient disconnect/reset responses. Harbor handled these through summarization or retry, and the affected logical trials continued.

These model-API retry records are separate from the three local task-runtime RPC failures described above.

The original failed result files were retained. Recovery never re-sampled a model attempt. Missing final ATIF turns were supplemented only when an exact raw API response had already been captured. Fresh-image grading was used only when the unchanged final patch could be verified byte-for-byte. Missing scores and command results were not fabricated.

Run provenance:

• Harbor-SWE commit: ab8ff9170ab4d9ecf1ff4e062defe44e1d5ed9ac
• Dataset source revision: laude-institute/harbor-datasets@86723674f04e4209ac479d0fb75d9d9f44b4377e
• Serving: eight independent vLLM replicas on one 8×H200 VISION node per model
• Scheduling: --n-attempts 16 --n-concurrent 32
• Model revisions: Qwen3.5-4B 851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a; Qwen3.5-9B c202236235762e1c871ad0ccb60c8ee5ba337b9a

---

Sonnet 4.6 direct-solving trajectories (added 2026-09-14)

These two subsets contain 100 complete direct-solving trajectories: 50 tasks per harness, using claude-sonnet-4-6. Both runs use the same fixed swebench-verified-mini 50 tasks, base commits, and original grading test scripts. Each task has one generated candidate per harness; all 100 candidates have final fresh-image grading results, with no grading infrastructure errors. These scores describe this fixed 50-task subset, not the complete SWE-bench Verified benchmark. No reviewer, reviewer revision, API preflight, stopped pilot, or later OpenHands SDK experiment is included in these two subsets.

Subset (test split)	Solving harness	Trajectories	Resolved	Accuracy
Sonnet-4.6-Agentless-Mini	Meta SWE-RL AGENTLESS-MINI	50	31/50	62%
Sonnet-4.6-OpenHands	SWE-Lego OpenHands 0.53.0, CodeActAgent	50	34/50	68%

Workflow and generation settings

Agentless Mini performs one localization call and one repair call per task, followed by deterministic patch selection/export. OpenHands runs the interactive CodeActAgent with native tool calls, then exports its final workspace diff. Both use temperature 0, no extended thinking, and one attempt per task.

Setting	Agentless Mini	OpenHands
Localization / repair samples	1 / 1	Interactive CodeActAgent
Maximum output tokens per call	4,096	16,384
Context setting	60,000 file-context tokens, measured with the Qwen3.5-4B tokenizer; excludes issue and prompt overhead	147,456 maximum input tokens
Iteration limit	2 model calls per task	100 agent iterations
Agent timeout	See archived trial configuration	3,000 seconds
Prompt caching	Disabled	Enabled
Condenser	Not applicable	NoOpCondenser
Generation concurrency	2	8
Grading concurrency	Initially 4, then 12	4

Token usage and measured time

Counts below cover the 50 direct-solving trials and successful model responses. The fresh-image grader makes no model calls. Full counters, configuration, and timing boundaries are in comparison.json.

Metric (all 50 tasks)	Agentless Mini	OpenHands
Successful model calls	100	2,629
Ordinary uncached input tokens	1,544,648	2,775
Cache-write input tokens	0	2,582,464
Cache-read input tokens	0	97,174,531
Normalized total input tokens	1,544,648	99,759,770
Output tokens	71,878	1,915,967
Total input + output tokens	1,616,526	101,675,737
Generation wall time	1h 30m 24s	1h 50m 32s
Generation start to final grading finish	1h 59m 01s	1h 53m 01s
Mean agent execution time per task	86.84 s	644.27 s

OpenHands' pinned LiteLLM logs count ordinary input plus cache reads in prompt_tokens, but record cache writes separately. Normalized input adds those cache writes exactly once. The original trajectory metrics are preserved; n_input_tokens follows the logged prompt count and normalized_input_tokens provides the normalized value. Repeated cached input is included, so the token ratio is not a billing-cost ratio.

The two runs used different concurrency and generation budgets. OpenHands graded while generation continued; Agentless Mini graded after generation, with a 4-to-12 worker handoff and four interrupted grading attempts restarted. Wall time includes environment setup and orchestration, so it is not a comparison at equal concurrency. Agent execution time includes framework, model, tool, and patch handling, and excludes environment setup and final grading; it is not pure API latency. Runs occurred on 2026-09-07 (OpenHands) and 2026-09-08 (Agentless Mini), UTC.

Load and locate a trajectory

import json
from datasets import load_dataset

mini = load_dataset(
    "ZhuofengLi/Harbor-SWE-Trajectory",
    "Sonnet-4.6-Agentless-Mini",
    split="test",
)
openhands = load_dataset(
    "ZhuofengLi/Harbor-SWE-Trajectory",
    "Sonnet-4.6-OpenHands",
    split="test",
)
assert len(mini) == len(openhands) == 50
assert sum(mini["reward"]) == 31
assert sum(openhands["reward"]) == 34
row = mini[0]
trajectory = json.loads(row["trajectory"])
grading = json.loads(row["grading_result"])
print(row["task_name"], row["raw_archive"], row["raw_trajectory_path"])

Each Parquet row contains the complete captured ATIF trajectory as a JSON string, original trial/job configuration and results, task/base commit, final reward, generated patch SHA-256, per-trial token counts and agent execution time. trial_result preserves the generation result, whose inline verifier is null; use the scalar reward and grading_result for the actual final score. The Sphinx grading wrapper adds verbose pytest output for result parsing; the original and executed script hashes are recorded separately in original_test_script_sha256 and verified_test_script_sha256. Both harnesses used identical original and executed scripts for each task. model_calls, uncached_input_tokens, cache_write_input_tokens, normalized_input_tokens, and total_tokens are derived from the raw API usage. n_cache_tokens counts cache reads; n_output_tokens counts generated tokens.

The two raw/<Sonnet subset>/...tar.gz archives preserve source-relative text logs under the original run-root name. Each contains all 50 trials, their original ATIF trajectories, native framework logs, raw model requests/responses, generated patches, final fresh-image grading reports, and run configuration/provenance. raw_trial_path, raw_trajectory_path, raw_model_patch_path, and raw_grading_path identify members. raw_api_path identifies agent/native/api.jsonl for Mini, or the agent/provider-completions/ directory of JSON call records for OpenHands. Other duplicated framework completion logs are preserved for provenance; use the designated raw API records for usage totals.

Full repository structure caches, workspace tarballs, binary session state, locks, and executable scripts are excluded. The exact prompts and code context sent to the model remain in the raw API records. High-confidence credential patterns are redacted with [REDACTED_CREDENTIAL]; per-file redaction counts and source/exported hashes are recorded. Original local artifacts are unchanged.

The addition has its own manifests under manifests/sonnet46-direct-20260914/: jobs.jsonl lists source directories, configurations, totals, archive hashes and excluded paths; files.jsonl lists every archived member and hash; export-summary.json records scope and cross-run consistency checks. All 100 published model patches match the SHA-256 recorded by their final grader. The original Qwen subsets and their historical manifests remain available.