Hugging Face's logo

Datasets:
JevAgentHarness
/
coding-agent-decisions

Tasks:
Text Classification
Modalities:
Tabular
Text
Formats:
parquet
Languages:
English
Size:
10K - 100K
ArXiv:
Tags:
agents
llm-agents
coding-agents
routing
decision-making
terminal-bench
Libraries:
Datasets
pandas
Polars
License:
Dataset card Data Studio Files
xet
 Community
coding-agent-decisions / README.md
Leozkl's picture
Leozkl
Add arXiv:2610.21412 citation and paper links
363f18f verified
preview code
|
Raw History Blame Contribute Delete
15.1 kB
metadata 
license: cc-by-nc-4.0
pretty_name: Coding-agent routing decisions (Terminal-Bench 2.0)
language:
  - en
task_categories:
  - text-classification
tags:
  - agents
  - llm-agents
  - coding-agents
  - routing
  - decision-making
  - terminal-bench
  - cost-efficiency
size_categories:
  - 10K<n<100K
configs:
  - config_name: states
    default: true
    data_files:
      - split: train
        path: states.parquet
  - config_name: steps
    data_files:
      - split: train
        path: steps.parquet
  - config_name: trials
    data_files:
      - split: train
        path: trials.parquet
  - config_name: decisions
    data_files:
      - split: train
        path: decisions.parquet
  - config_name: runs
    data_files:
      - split: train
        path: runs.parquet

Coding-agent routing decisions (Terminal-Bench 2.0)

Logs of the open-source routing proxy jah (JevAgentHarness, github.com/JevAgentHarness/JevAgentHarness) running five unmodified coding-agent harnesses on Terminal-Bench 2.0 through Harbor 0.24.0, October 2026. For every agent step the proxy asked a decision model whether the next step is routine or hard, sent hard steps to a strong LLM and routine steps to a fast one, and logged the decision model's exact input, its probability p(hard), the tier and the cost. Each trial's outcome is joined from Harbor's results.

Use it to train or evaluate step-level routers for coding agents: the states with p(hard) and the route, and per trial whether the routed agent solved the task, at what cost and in how much time.

Setup

  • Harnesses (harness): codex (Codex CLI 0.162.1), pi (pi 1.2.0), dsh (DeepSeek Harness 0.2.1-alpha.2), mswe (mini-swe-agent) and t2 (Terminus-2, Harbor's reference agent). Each uses its own prompts and tools; only the model endpoint is the proxy.
  • Tiers (runs.tiers): strong Gemini 4 Argon (thinking high) with a fast Gemini 3.8 Flash (thinking low) or Gemini 3.5 Flash-Lite (thinking low); for Codex in the test run, strong GPT-6.1 Sol (medium) with fast GPT-6 Luna (low). Costs are the providers' list prices of October 2026.
  • Decision model: Jev (typesafe/jev-1.13, TypeSafe) through OpenRouter. It was asked: "Decide how hard the agent's NEXT step is. 'routine': the next step follows directly from what the agent already knows ... 'hard': the next step needs careful reasoning ..." (the full text is QUESTION in src/jevagentharness/router.py).
  • Arms (arm, the model name the harness asks the proxy for): jah-strong (every step strong, the baseline), jah-auto (routed, the step goes to the strong tier when p(hard) >= 0.5), jah-auto-t75 (threshold 0.75), jah-fast (every step fast), and dev-only variants (jah-auto-t85, jah-auto-t75m, jah-auto-eff; the modes arms jah-shadow, jah-safe, jah-stopguard, jah-submit, jah-reflect, jah-routeguard). Routed arms always put the first step on the strong tier and re-do a fast-tier reply without a tool call on the strong tier (the finish check). The arms are defined in the repository's bench/configs/*.yaml (runs.proxy_config).
  • Tasks: Terminal-Bench 2.0 (89 tasks, laude-institute/terminal-bench-2 at commit 69671fbaac6d67a7ef0dfec016cc38a64ef7a77c) with a fixed hash split into 15 dev and 74 test tasks (task_split), and a 20-task test subset for the Codex row (in_test20). One trial per task and arm.
  • Phases (phase): dev (router settings explored), dev_modes (the decision-point modes of the repository's docs/modes.md, dev tasks only), test (the reported runs, settings fixed in bench/PROTOCOL.md before they ran).
Run (run) Phase Proxy config Harnesses and arms
dev1 dev bench/configs/gemini_argon_flash.yaml codex: jah-auto, jah-fast, jah-strong; dsh: jah-auto, jah-fast, jah-strong; pi: jah-auto, jah-fast, jah-strong
dev1c dev bench/configs/gemini_argon_flash.yaml codex: jah-auto, jah-fast, jah-strong
dev2 dev bench/configs/gemini_argon_flash.yaml codex: jah-auto-t75, jah-auto-t85; dsh: jah-auto-t75, jah-auto-t85; pi: jah-auto-t75, jah-auto-t85
dev3 dev bench/configs/gemini_argon_flash.yaml codex: jah-auto, jah-auto-t75m
dev4 dev bench/configs/gemini_argon_flash.yaml codex: jah-auto-eff; dsh: jah-auto-eff; pi: jah-auto-eff
dev-lite dev bench/configs/gemini_argon_lite.yaml mswe: jah-auto, jah-auto-t75; pi: jah-auto, jah-auto-t75, jah-strong
dev-lite2 dev bench/configs/gemini_argon_lite.yaml mswe: jah-strong
dev-modes dev_modes bench/configs/gemini_argon_lite_modes.yaml mswe: jah-safe, jah-shadow; pi: jah-shadow, jah-stopguard
dev-modes2 dev_modes bench/configs/gemini_argon_lite_modes.yaml mswe: jah-auto-t75, jah-reflect, jah-routeguard, jah-submit
dev-modes3 dev_modes bench/configs/gemini_argon_lite_modes.yaml mswe: jah-auto-t75, jah-reflect; pi: jah-reflect
test-gem test bench/configs/gemini_argon_flash.yaml dsh: jah-auto, jah-strong; pi: jah-auto, jah-strong
test-gem1 test bench/configs/gemini_argon_flash.yaml mswe: jah-auto, jah-strong; t2: jah-auto, jah-strong
test-lite test bench/configs/gemini_argon_lite.yaml dsh: jah-auto-t75; mswe: jah-auto-t75; pi: jah-auto-t75; t2: jah-auto-t75
test-codex test bench/configs/openai_sol_luna.yaml codex: jah-auto, jah-strong

dev1c holds Codex reruns of dev1; their steps are in dev1's proxy log, so steps lists them under run dev1.

Configs

Config Rows One row per
states (default) 16,368 routed step: the decision model's exact input, p(hard) and the tier
steps 42,427 proxy step (all arms, routed or not) and context-cache event
trials 1,508 Harbor trial (harness x arm x task) with its outcome
decisions 6,533 decision-point question of the dev_modes runs
runs 14 run folder: tiers, decision model, proxy config, spend

Join states and steps with trials on (run, session) or (arm, trial); session is <arm>/<trial>. States exist for the runs test-lite, test-gem, test-gem1, test-codex, dev-lite and dev4 (the proxy wrote them only when its state log was on).

Fields

states: run, session, arm, harness, task, trial, step (assistant turns before this one), ts, state (the text the decision model read: TASK: with the task text, STEPS SO FAR:, then the last six actions with their results, truncated as in render_state of router.py), p_hard (Jev's probability for hard), tier (the tier that wrote the step: strong, fast, or in dev runs fast_med = Gemini 3.8 Flash at medium thinking and strong_low = Gemini 4 Argon at low thinking, the fast tier of jah-auto-eff) and reason (routine / hard = the decision, decision_error = no answer, so the step went to the strong tier).

steps: identification as above plus event (step or cache, a context-cache write that only costs money), tier, reason (also pinned = an unrouted arm, first_steps, finish_check, guard, reflection, route_guard, stop_guard, fast_error, and repeat:<reason> when a harness re-sent the same step), p_hard, llm_cost_usd, decision_cost_usd, cost_usd, latency_s, token counts (input_tokens, cached_tokens, cache_write_tokens, output_tokens, reasoning_tokens), n_tool_calls, finish, finish_check, calls (each LLM call: tier, model, latency, attempts, cost), decision_model, decision_latency_s, decision_input_tokens, decision_state_chars, cache_model, cache_tokens, points and redo (the modes runs: what each decision point answered and which checks made the strong tier re-do the step), and error, decision_error, fast_tier_error (short codes such as upstream HTTP 503).

trials: run, phase, proxy_config, strong_model, strong_effort, fast_model, fast_effort, decision_model, harness, arm, task, trial, task_split, in_test20, success (Harbor reward = 1), cost_usd (LLM + decision-model dollars logged by the proxy for the trial's session), decision_cost_usd, agent_s (Harbor's agent-execution seconds), llm_s, steps, strong_share, proxy_errors, exception (Harbor's exception type, such as AgentTimeoutError), infra_error, timeout, has_proxy_log (false when the trial failed before its first LLM call) and reported_in (test_flash_lite, test_argon_flash or test_codex_openai when the trial is part of a reported comparison).

decisions (dev_modes runs): point (routing, tool_select, stop, reflection, action), mode (cascade, shadow, guard, trigger, ...), question, options, p (one probability per option), choice, confidence, tau, act_option, p_act, acted, effect, label and label_tier (what the strong tier did, where known), agree, fit_ok, latency_s, cost_usd, decision_model, rounds, error, route_tier, guard_tool, guard_pattern. The states of these questions were not logged.

runs: run, phase, proxy_config, proxy_log, trials, jobs, tiers (JSON), decision, tau_default, proxy_spent_usd, proxy_budget_usd.

How the trial table was made

trials is the output of the repository's bench/summarize.py (load_trials, load_steps and join, the same functions as python bench/summarize.py JOBS PROXY --per-task), one call per run. Its compare function, run on the trials rows of each reported comparison, reproduces the repository's bench/results/*.json exactly. The reported test results:

Gemini 4 Argon + Gemini 3.5 Flash-Lite, routed at tau = 0.75 (test, 74 tasks; test_flash_lite)

harness:arm n success Δ vs jah-strong (pt) [95% CI] $/task cost saving agent s/task time saving strong share
dsh:jah-auto-t75 74 66.2% +0.0 [-8.1, +8.1] 0.682 27.8% 684 15.0% 50.1%
dsh:jah-strong 74 66.2% baseline 0.944 – 805 – 100.0%
mswe:jah-auto-t75 74 63.5% -2.7 [-14.9, +8.1] 0.330 63.7% 471 42.8% 45.4%
mswe:jah-strong 74 66.2% baseline 0.909 – 824 – 100.0%
pi:jah-auto-t75 74 56.8% +4.1 [-6.8, +14.9] 0.424 31.1% 650 4.5% 54.6%
pi:jah-strong 74 52.7% baseline 0.616 – 680 – 100.0%
t2:jah-auto-t75 74 41.9% +14.9 [+4.1, +25.7] 0.135 -27.3% 967 28.8% 44.4%
t2:jah-strong 74 27.0% baseline 0.106 – 1357 – 100.0%

Gemini 4 Argon + Gemini 3.8 Flash, routed at tau = 0.5 (test, 74 tasks; test_argon_flash)

harness:arm n success Δ vs jah-strong (pt) [95% CI] $/task cost saving agent s/task time saving strong share
dsh:jah-auto 74 70.3% +4.1 [-5.4, +13.5] 0.882 6.6% 629 21.8% 50.4%
dsh:jah-strong 74 66.2% baseline 0.944 – 805 – 100.0%
mswe:jah-auto 74 74.3% +8.1 [+0.0, +17.6] 0.788 13.3% 686 16.7% 52.3%
mswe:jah-strong 74 66.2% baseline 0.909 – 824 – 100.0%
pi:jah-auto 74 59.5% +6.8 [-2.7, +17.6] 0.554 10.1% 563 17.2% 56.5%
pi:jah-strong 74 52.7% baseline 0.616 – 680 – 100.0%
t2:jah-auto 74 33.8% +6.8 [+0.0, +13.5] 0.192 -81.8% 1263 6.9% 51.7%
t2:jah-strong 74 27.0% baseline 0.106 – 1357 – 100.0%

Codex with GPT-6.1 Sol + GPT-6 Luna, tau = 0.5 (20 test tasks; test_codex_openai)

harness:arm n success Δ vs jah-strong (pt) [95% CI] $/task cost saving agent s/task time saving strong share
codex:jah-auto 20 85.0% +0.0 [-15.0, +15.0] 0.158 6.5% 273 -46.9% 52.9%
codex:jah-strong 20 85.0% baseline 0.169 – 186 – 100.0%

Each routed arm is compared with the jah-strong arm of the same harness on the tasks both completed. Δ is the difference in success in points. "Cost saving" and "time saving" compare the totals over the same tasks. For the Flash-Lite row the baseline is the jah-strong arm of the Argon + Flash test runs (same strong tier, harness version and tasks; bench/PROTOCOL.md, "Changes"). The Codex row is a 20-task check, not a claim.

What was left out

  • States of sanitize-git-repo (198 rows): the task plants fake credentials (AWS, GitHub and Hugging Face key-shaped strings) in a repository for the agent to remove, and they appear in the states. Its steps and trials rows are kept.
  • 14 further states whose text names a commercial AI assistant or its vendor (in task files, in a package path and in text an agent wrote), and 2 states that show the benchmark host's run directory (a container's mount table). Their steps and trials rows are kept.
  • Harbor's agent trajectories, terminal recordings, verifier output and logs, the proxy's server logs, error messages (only short codes are kept), the runs smoke and smoke-gem2 (plumbing checks) and two assembled views of the test runs that would duplicate rows.

Licence and third-party content

  • Licence: CC BY-NC 4.0 (non-commercial) for the logs, the joined outcomes and the tables, because they contain outputs of commercial models (the Jev decision model and Gemini or OpenAI agent text) whose redistribution terms we cannot extend to commercial use.
  • Terminal-Bench 2.0 task texts and task-container contents (files, command output) appear in state. Terminal-Bench 2.0 is released under the Apache-2.0 licence (github.com/laude-institute/terminal-bench-2); keep its attribution and licence notice. Some task data contains names and e-mail addresses from public software projects (for example git history); they come from the benchmark.
  • Model output: the actions in state were written by Gemini 4 Argon, Gemini 3.8 Flash and Gemini 3.5 Flash-Lite (Google) or by GPT-6.1 Sol and GPT-6 Luna (OpenAI, test-codex); p_hard and the decision probabilities are outputs of Jev (TypeSafe). Check these providers' terms before you use the data commercially, in particular for training a model that competes with theirs.
  • By design no provider key entered a task container: each agent got a dummy key and only the proxy held the real ones. The files were scanned for our keys and for key-shaped strings before release.

Citation 

@misc{zhu2026jevagentharnessbenchmarkingdeployingtraining,
      title={JevAgentHarness: Benchmarking, Deploying and Training Decision Models That Share Control with LLMs},
      author={Kunlun Zhu and Tao Feng and Xu Han and Heng Wang and Ling Yang and Xiangru Tang and Jiaxuan You and Heng Ji},
      year={2026},
      eprint={2610.21412},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2610.21412},
}