Claude Opus 5.5 (effort default (no --effort flag) · thinking on) on Optimal single-machine job sequence (weighted tardiness with precedence)

AClaude Opus 5.5default · thinking on · Claude Code 2.1.299 (headless -p) · cloud · 2026-10-20 · by @bobsiopener

Trust 80%Fully autonomoussuccess · first tryCompare

Estimated cost: $0.17
Wall time: 50s
Human step-ins: 0
Outcome: Pass

Compare with other models on this task →

Exact prompt

# Optimal job sequence: minimum total weighted tardiness with precedence `input.json` (synthetic) has `start` (time the machine becomes free), `jobs` (`id`, processing time `p`, weight `w`, `due`) and `precedence` (pairs [a, b]: a must come before b, not necessarily directly). One machine, no idle time, no preemption. Write `solve.py` (Python 3 standard library only); `python solve.py input.json answer.json`. Find a sequence of all jobs that respects every precedence pair and **minimises** total weighted tardiness: sum of w * max(0, C - due), where C is the job's completion time (start + sum of p up to and including the job). Any optimal sequence is accepted. Fresh instances have **20 and 21 jobs**; each run has a 90-second limit. ## answer.json `{"sequence": [job ids in order], "total_weighted_tardiness": integer}` ## Scoring Hidden checks (partial credit; all must pass). A sequence is **valid** if it is a permutation of the job ids, respects every precedence pair, and the reported objective equals the scorer's recomputation for that sequence. It is **optimal** if that objective equals the true minimum (the scorer has the optimum). `fixture_valid_sequence`, `fixture_optimal` (given 18-job instance); `fresh_20_jobs_valid`, `fresh_20_jobs_optimal`; `fresh_21_jobs_optimal`.

Greedy rules (WSPT, EDD, swaps) give valid but suboptimal sequences; an exact method (subset dynamic programming or a tight branch and bound) is needed. Original benchmark task written for usecaserank.com (not based on a specific public post). Headless, offline run on a reproducible fixture. Each run's notes say how its cost was measured (estimates are marked).

Success criteria: 1. fixture_valid_sequence 2. fixture_optimal 3. fresh_20_jobs_valid 4. fresh_20_jobs_optimal 5. fresh_21_jobs_optimal

Setup notes: Use Case Scout batch 12 case m07-weighted-tardiness-optimal (offline, synthetic fixture). Prepared with batch12/prepare.sh; hidden key/checker kept outside the agent's work dir (temp dir during the run). Prompt = TASK.md verbatim. Scored with the case's scorer: `python score.py WORKDIR KEYDIR` (python3, run from the case dir). Tools: Read/Write/Edit/Glob/Grep/Bash, web disabled. Single run, no retries. 1-min load average at scoring 1.04 (8 cores). Claude Code's own reported cost for claude-opus-5.5: $0.174724. Score: 5/5. Cost is an ESTIMATE: measured tokens x pricing.json list price (Claude Pro subscription, nothing billed); input_tokens include cache reads and writes. Single run.

Estimated cost List-price estimate; not actually billed.

Metrics

Estimated cost: $0.17
Wall time: 50s
Human step-ins: 0
Turns: 5

Model usage
Model	Input tok	Output tok	Cost
AClaude Opus 5.5anthropic/claude-opus-5.5effort default (no --effort flag) · thinking on	101,840	3,702	$0.17

Reproduce this run

Use the use case prompt on the use case page.
Same setup: Claude Opus 5.5 (anthropic/claude-opus-5.5, effort default (no --effort flag) · thinking on) via Claude Code 2.1.299 (headless -p), cloud.
It counts as a success only if it meets every success criterion: 1. fixture_valid_sequence 2. fixture_optimal 3. fresh_20_jobs_valid 4. fresh_20_jobs_optimal 5. fresh_21_jobs_optimal
Log model, tokens, wall time, human step-ins and the evidence log, then submit it as a reproduction. A different model? Submit a head-to-head rerun.

How runs are scored: Methodology.

Was this useful?

⇄ Rerun on another model

Automated checks

Trust 80% comes from these checks (how Trust % works).

Run date is not in the future : passed
Model is in the dated pricing table : passed
Cost recomputed from tokens matches : passed
Cached tokens are consistent : passed
Output throughput is plausible : passed
Autonomy matches step-ins : passed
Step-ins do not exceed turns : passed
Retries agree with first-try result : passed
Evidence log SHA-256 matches : passed
Evidence log is substantial : passed

Evidence log

[
 {
  "duration_api_ms": 45290,
  "stop_reason": "end_turn",
  "session_id": "[REDACTED]",
  "total_cost_usd": 0.17472359999999998,
  "usage": {
   "input_tokens": 10,
   "cache_creation_input_tokens": 10292,
   "cache_read_input_tokens": 91538,
   "output_tokens": 3702,
   "output_tokens_details": {
    "thinking_tokens": 1182
   },
   "server_tool_use": {
    "web_search_requests": 0,
    "web_fetch_requests": 0
   },
   "service_tier": "standard",
   "cache_creation": {
    "ephemeral_1h_input_tokens": 10292,
    "ephemeral_5m_input_tokens": 0
   },
   "inference_geo": "global",
   "iterations": [
    {
     "input_tokens": 2,
     "output_tokens": 552,
     "cache_read_input_tokens": 21519,
     "cache_creation_input_tokens": 919,
     "cache_creation": {
      "ephemeral_5m_input_tokens": 0,
      "ephemeral_1h_input_tokens": 919
     },
     "type": "message"
    }
   ],
   "speed": "standard",
   "fallback_credit": null
  },
  "modelUsage": {
   "claude-opus-5-5": {
    "inputTokens": 10,
    "outputTokens": 3702,
    "cacheReadInputTokens": 91538,
    "cacheCreationInputTokens": 10292,
    "webSearchRequests": 0,
    "costUSD": 0.17472359999999998,
    "contextWindow": 1000000,
    "maxOutputTokens": 128000,
    "thinkingTokens": 1182,
    "canonicalModel": "claude-opus-5-5",
    "provider": "firstParty",
    "costBasis": "list"
   }
  },
  "permission_denials": [],
  "terminal_reason": "completed",
  "fast_mode_state": "off",
  "fast_mode_disabled_reason": "sdk_opt_in_required",
  "subagent_stats": {
   "spawned": 0,
   "requested": {
    "background": 0,
    "foreground": 0,
    "unset": 0
   },
   "started_in_background": 0,
   "max_depth": 0,
   "spawned_by_subagents": 0,
   "completed": 0,
   "failed": 0,
   "killed": {
    "parent": 0,
    "user": 0,
    "system": 0
   },
   "refused": {
    "depth_limit": 0,
    "concurrency_limit": 0,
    "budget": 0
   },
   "by_type": {}
  },
  "safety_stops": 0,
  "is_error": false,
  "num_turns": 5,
  "subtype": "success",
  "api_error_status": null,
  "result": "I wrote `solve.py`. It finds the true minimum, not just a good guess.\n\n**How it works:** it uses dynamic programming over sets of jobs. For each set S that could be the jobs run first, it works out the lowest weighted tardiness for scheduling S. The last job in S always finishes at `start + sum(p over S)`, so each set only has to try each job that is allowed to go last. Precedence pairs are expanded first, so indirect \"must come before\" links are covered too. The script then rebuilds the sequence from the stored choices and writes `{\"sequence\", \"total_weighted_tardiness\"}`.\n\n**What I checked:**\n- **Given 18-job fixture:** runs in 0.3 s with an objective of 462. I can't confirm 462 is optimal against the scorer, since the scorer's optimum isn't available to me.\n- **Correctness:** in 300 random small instances (up to 7 jobs, random precedence), the result matched a brute-force search over every allowed order. Each time, the sequence was a valid permutation that respected precedence, and the reported objective matched a recomputation from the sequence.\n- **Speed:** a random 21-job instance with almost no precedence (close to the slowest case) took about 2.6 s on Python 3.13, well under the 90 s limit.\n\nMemory use grows as 2\u207f, so it's fine at 21 jobs but would get heavy well past about 24.",
  "ttft_ms": 4370,
  "type": "result",
  "duration_ms": 49002,
  "uuid": "[REDACTED]",
  "ttft_stream_ms": 2492,
  "time_to_request_ms": 307,
  "first_content_frame_ms": 2492,
  "queued_turn_count": 0,
  "result_index": 0
 }
]