Update dataset

README.md

@@ -25,10 +25,10 @@ A benchmark dataset for evaluating AI systems on challenging computer science pr
 
 ## Dataset Description
 
-This dataset contains 267 problems across three categories:
+This dataset contains 268 problems across three categories:
 - **Algorithmic**: 188 competitive programming problems with automated judging
 - **Research**: 66 open-ended research problems
-- **2.0**: 13 next-generation open-ended optimization problems
+- **2.0**: 14 next-generation open-ended optimization problems
 
 ## Dataset Structure
 

data/test-00000-of-00001.json

@@ -265,3 +265,4 @@
 {"problem_id": "vector_db_ann", "category": "2.0", "statement": "# Vector DB ANN\n\n## Problem\n\nBuild a fast approximate nearest-neighbor vector search engine for a\nSIFT1M-scale benchmark.\n\nThe hidden benchmark contains exactly `1,000,000` base vectors with dimension\n`128`. Queries use the same dimension, distance is squared Euclidean distance,\nand each query asks for the top `10` nearest vector ids.\n\nYour objective is to maximize serving throughput while preserving search\nquality: submissions must reach `recall@10 >= 0.95`, and valid submissions are\nranked by an effective QPS that includes query time plus a small load/index-build\npenalty.\n\nThe Harbor agent container starts with a small Rust skeleton project in\n`/app`. You may use it, modify it, or replace it entirely. You may also use any\nRust crates, internal harness, data structures, and build layout you want, as\nlong as the final project satisfies the judge contract below.\n\nThe judge builds and runs your service with:\n\n```bash\ncargo build --release\nPORT=<port> cargo run --release --quiet\n```\n\nThe Harbor environment uses the Ubuntu `apt` Rust toolchain:\n\n```text\nrustc 1.75\ncargo 1.75\n```\n\nIf you add crates, choose versions compatible with this toolchain or pin\ntransitive dependencies accordingly.\n\nThe service and judge run with the task resource limits below. Design your\nparallel search and indexing strategy for this budget:\n\n```text\nvCPUs: 8\nmemory: 16 GiB\nquery concurrency: 8\ntimed queries per worker: 64\n```\n\nThe service must listen on `PORT` and implement these endpoints:\n\n```text\nPOST /insert\nPOST /bulk_insert\nPOST /search\n```\n\n`/bulk_insert` receives:\n\n```json\n{\"vectors\":[{\"id\":0,\"vector\":[0.1,0.2,...]}]}\n```\n\nand returns:\n\n```json\n{\"status\":\"ok\",\"inserted\":1}\n```\n\n`/search` receives:\n\n```json\n{\"vector\":[0.1,0.2,...],\"top_k\":10}\n```\n\nand returns:\n\n```json\n{\"results\":[{\"id\":0,\"distance\":0.0}]}\n```\n\n## Local Harness\n\nThe official evaluator uses hidden data and a black-box judge. You may call:\n\n```bash\nbash /app/submit.sh\n```\n\nat any time to submit the current `/app` project to the official judge and get\nscore feedback.\n\n## Validity\n\nA submission is valid if:\n\n1. It builds successfully with `cargo build --release`.\n2. `cargo run --release --quiet` starts the service and implements the required HTTP\n   endpoints.\n3. Every returned id is in `[0, 1_000_000)`.\n4. Its `recall@10` is at least `0.95` against the hidden exact top-10 ground\n   truth.\n\n## Scoring\n\nAt trial startup, the Harbor judge sidecar prepares the hidden benchmark and\nruns an exact-search reference HTTP service through the same `/bulk_insert`\nand `/search` client harnesses to produce ground-truth nearest neighbors and\nthe trial-local scoring baseline:\n\n```text\nbaseline_qps\nbaseline_effective_qps\nbaseline_load_seconds\n```\n\nInteractive submissions and the final verifier both score through this same\njudge sidecar, so the baseline and runtime environment are shared within a\ntrial while still letting different machines measure their own local baseline.\n\nEach submission is then timed independently. The load phase includes all\n`/bulk_insert` calls and any index construction performed by the service before\nqueries begin. The query phase uses 8 concurrent workers, each issuing 64\nqueries, and measures only `/search` throughput:\n\n```text\ncandidate_qps\ncandidate_load_seconds\n```\n\nThe reported `qps` is the raw query-only QPS. Scoring uses an effective QPS\nthat includes a small index-build/load penalty:\n\n```text\neffective_qps = Q / (query_seconds + 0.01 * load_seconds)\n```\n\nThe load phase has a default `900s` timeout. This keeps the benchmark focused\non serving performance while still making very expensive offline indexing pay a\nbounded, explicit cost.\n\nDuring evaluation, the load and query phases may stop early and return `0` once\nthe elapsed time plus the load penalty makes it impossible for the final\neffective QPS to beat the baseline. During load, this assumes a best-case query\ntime of zero.\n\nIf the submission is invalid, if `recall@10 < 0.95`, or if\n`candidate_effective_qps <= baseline_effective_qps`, the score is `0`.\nOtherwise:\n\n```text\nscore = 100 * (1 - sqrt(baseline_effective_qps) / sqrt(candidate_effective_qps))\n```\n\nThe bounded and unbounded score fields both report this score. Harbor JSON\nresults include the measured `qps`, `effective_qps`, `baseline_qps`,\n`baseline_effective_qps`, `recall_at_10`, load time, and runtime metrics under\nthe `metrics` field.\n", "config": "tag: systems\nruntime:\n  language: rust\n  timeout_seconds: 10800\n  environment: \"Rust project; hidden ANN benchmark; Python/NumPy judge\"\n  apt_packages:\n    - build-essential\n    - cargo\n    - git\n    - rustc\n  judge_apt_packages:\n    - build-essential\n    - cargo\n    - rustc\n    - python3-pip\n    - python3-numpy\n  judge_pip_packages:\n    - faiss-cpu\n  docker:\n    image: ubuntu:24.04\nenvironment:\n  # If these resource limits change, also update the resource budget text in\n  # readme and harbor/app/README.md so agents can design parallel algorithms\n  # for the actual CPU and memory budget.\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\nevaluation:\n  # The judge drives the search service with this many concurrent workers.\n  # Keep this aligned with the CPU budget unless the task is intentionally\n  # changed into a higher-concurrency service benchmark.\n  query_concurrency: 8\n  queries_per_worker: 64\nsubmission:\n  kind: directory\n  path: /app\n  exclude:\n    - target\n    - .git\n    - .frontier-cs\n"}
 {"problem_id": "vector_db_ann_disk", "category": "2.0", "statement": "# Vector DB ANN Disk\n\n## Problem\n\nBuild a fast approximate nearest-neighbor vector search engine for a\nSIFT100M-scale benchmark.\n\nThe hidden benchmark contains exactly `100,000,000` base vectors with dimension\n`128`. Queries use the same dimension, distance is squared Euclidean distance,\nand each query asks for the top `10` nearest vector ids.\n\nThe benchmark provides a pre-built graph index generated using the [DiskANN](https://github.com/g4197/FreshDiskANN-baseline)\nconstruction algorithm. The graph has a bounded maximum degree and is stored on\ndisk. Your objective is to maximize serving throughput while preserving search\nquality: submissions must reach `recall@10 >= 0.95`, and valid submissions are\nranked by query throughput.\n\nThe Harbor agent container starts with a small Rust skeleton project in\n`/app`. You may use it, modify it, or replace it entirely. You may also use any\nRust crates, internal harness, data structures, and build layout you want, as\nlong as the final project satisfies the judge contract below.\n\nThe judge builds and runs your service with:\n\n```bash\ncargo build --release\nPORT=<port> cargo run --release --quiet\n```\n\nThe Harbor environment uses the Ubuntu `apt` Rust toolchain:\n\n```text\nrustc 1.75\ncargo 1.75\n```\n\nIf you add crates, choose versions compatible with this toolchain or pin\ntransitive dependencies accordingly.\n\nThe service and judge run with the task resource limits below. Design your\nsearch strategy for this budget:\n\n```text\nvCPUs: 8\nmemory: 8 GiB\nquery concurrency: 8\n```\n\nThe graph and vector data may be substantially larger than the available\nmemory. Submissions may load any information they deem useful into memory\nduring the load phase, subject to the memory limit above.\n\nThe load phase is executed once before queries begin and must complete within:\n\n```text\n600 seconds\n```\n\nThe service must listen on `PORT` and implement these endpoints:\n\n```text\nPOST /load\nPOST /search\n```\n\nImportant: submissions must implement an online ANN service that answers each\n`/search` using the index and vectors provided through `/load`. Query vectors are\nsupplied by the evaluator at request time. Results must come from searching the\nprovided index; do not hardcode answers or rely on any precomputed or external\ndata. Any attempt to obtain results other than by searching the provided index is\noutside the task contract and is treated as invalid.\n\nOptimization guidance: after a valid graph-based ANN implementation exists,\nminor parameter sweeps over search-list size, beam width, or cache limits tend\nto provide limited gains. Prefer substantive algorithmic and I/O improvements,\nsuch as better graph traversal, batching/asynchronous disk reads, candidate\nmanagement, vector/PQ distance computation, and cache design. A well-designed\nANN algorithmic change is expected to be a better acceleration path than\nrepeated manual tuning of a few constants.\n\n`/load` receives the paths to the pre-built index and vector data:\n\n```json\n{\n    \"index_path\":\"graph.bin\",\n    \"vector_path\":\"vectors.bin\",\n    \"vector_dtype\":\"uint8\",\n    \"pq_compressed_path\":\"pq_compressed.bin\",\n    \"pq_pivots_path\":\"pq_pivots.bin\"\n}\n```\n\nFor compatibility, the service should also accept `graph_path` as an alias for\n`index_path`, and `pq_vector_path` as an alias for `pq_compressed_path`.\n`vector_dtype` is optional and may be `float32`, `uint8`, or `int8`; do not\nassume the vector file stores `float32` rows. These files follow the same format\nand organization as those in the [provided repository](https://github.com/g4197/FreshDiskANN-baseline);\nyou can refer to it to load the graph, compressed vectors, and other required\ndata structures.\n\nand returns:\n\n```json\n{\n    \"status\":\"ok\"\n}\n```\n\n`/search` receives:\n\n```json\n{\"vector\":[0.1,0.2,...],\"top_k\":10}\n```\n\nand returns:\n\n```json\n{\"results\":[{\"id\":0,\"distance\":0.0}]}\n```\n\n## Local Harness\n\nThe official evaluator uses hidden data and a black-box judge. You may call:\n\n```bash\nbash /app/submit.sh\n```\n\nat any time to submit the current `/app` project to the official judge and get\nscore feedback.\n\nEach evaluation rebuilds your project, runs `/load` once (loading the on-disk\nindex can take tens of seconds), then runs the timed query phase, so a single\nsubmission takes on the order of a few minutes to score. Submissions are\nasynchronous: prefer to let a running evaluation finish and read its score\nrather than cancelling and resubmitting repeatedly. To keep iterative feedback\nresponsive, an agent `submit.sh` evaluation times only a representative subset\nof the query set (see below); the final score is always computed over the full\nset.\n\n## Validity\n\nA submission is valid if:\n\n1. It builds successfully with `cargo build --release`.\n2. `cargo run --release --quiet` starts the service and implements the required HTTP\n   endpoints.\n3. Every returned id is in `[0, 100_000_000)`.\n4. Its `recall@10` is at least `0.95` against the hidden exact top-10 ground\n   truth.\n5. The `/load` phase completes within `600` seconds.\n\n## Scoring\n\nEach submission is scored against a hidden exact top-10 ground truth and a\nreference throughput baseline (`baseline_qps`) measured under the same `/load`\nand `/search` harness.\n\nThe load phase consists of a single `/load` call. Any preprocessing performed\nduring `/load` must complete within the timeout above.\n\nAfter the load phase completes, the query phase uses 8 concurrent workers to\nissue the timed query set and measures only `/search` throughput\n(`candidate_qps`). The reported `qps` is the raw query-only QPS.\n\nIf the submission is invalid, if `recall@10 < 0.95`, or if\n`candidate_qps <= baseline_qps`, the score is `0`.\n\nOtherwise:\n\n```text\nscore = 100 * (1 - sqrt(baseline_qps) / sqrt(candidate_qps))\n```\n\nThe bounded and unbounded score fields both report this score. Harbor JSON\nresults include the measured `qps`, `baseline_qps`, `recall_at_10`, load time,\nand runtime metrics under the `metrics` field.\n\n### Iterative feedback vs. final scoring\n\nTo make the `submit.sh` loop responsive, an iterative (agent) submission times\nonly a representative subset of the query set (`2000` queries by default) and\nreports it as a fast estimate; its message is prefixed with `[iterative]` and\nstates how many queries were used. The **final verifier** always times the full\nquery set (`Q = 10000`) and reports the authoritative `[final]` score using the\nexact same scoring rule. recall@10 and QPS are stable averages, so the iterative\nestimate closely tracks the final score; use it to iterate quickly, and rely on\nthe final score for the definitive number. (The subset size is the `metrics`\nfield `n_queries`; the full count is `n_queries_full`.)\n", "config": "tag: systems\nruntime:\n  language: rust\n  timeout_seconds: 10800\n  environment: \"Rust project; hidden disk ANN benchmark; Python/NumPy judge\"\n  apt_packages:\n    - build-essential\n    - cargo\n    - git\n    - rustc\n  judge_apt_packages:\n    - build-essential\n    - cargo\n    - rustc\n    - python3-pip\n    - python3-numpy\n  judge_pip_packages:\n    - faiss-cpu\n  docker:\n    # Agent image is the default ubuntu:24.04 (the agent needs no hidden data).\n    # The judge image bakes the SIFT100M benchmark data in; build it before a\n    # local Harbor trial with 2.0/problems/vector_db_ann_disk/docker/build_images.sh.\n    image: ubuntu:24.04\n    judge_image: frontiercs/vector-db-ann-disk-judge:experimental-v1\nenvironment:\n  # If these resource limits change, also update the resource budget text in\n  # readme and harbor/app/README.md so agents can design parallel algorithms\n  # for the actual CPU and memory budget.\n  cpus: 8\n  memory_mb: 8192\n  storage_mb: 8192\n  build_timeout_seconds: 3600\nevaluation:\n  # The judge drives the search service with this many concurrent workers.\n  # Keep this aligned with the CPU budget unless the task is intentionally\n  # changed into a higher-concurrency service benchmark.\n  query_concurrency: 8\n  # Fallback only: the actual timed query count is pinned to the full official\n  # query set via FRONTIER_VECTOR_DB_Q=10000 in docker/judge/Dockerfile, which\n  # overrides this. (The local CI smoke in evaluate.sh sets its own small Q.)\n  queries_per_worker: 64\n# The hidden benchmark data is baked into the custom judge image\n# (runtime.docker.judge_image); the data paths, dtype, N=100,000,000, and\n# Q=10,000 are pinned as ENV in docker/judge/Dockerfile. truth.bin / baseline.json\n# live under /data/private_100M, which is never passed to /load.\nsubmission:\n  kind: directory\n  path: /app\n  exclude:\n    - target\n    - .git\n    - .frontier-cs\n"}
 {"problem_id": "vector_db_ann_relaxed", "category": "2.0", "statement": "# Vector DB ANN Relaxed\n\n## Problem\n\nBuild a fast approximate nearest-neighbor vector search engine for a\nSIFT1M-scale benchmark. This relaxed variant uses the same data, API, resource\nbudget, and recall target as Vector DB ANN, but penalizes load/index-build time\n10x less heavily.\n\nThe hidden benchmark contains exactly `1,000,000` base vectors with dimension\n`128`. Queries use the same dimension, distance is squared Euclidean distance,\nand each query asks for the top `10` nearest vector ids.\n\nYour objective is to maximize serving throughput while preserving search\nquality: submissions must reach `recall@10 >= 0.95`, and valid submissions are\nranked by an effective QPS that includes query time plus a small\nload/index-build penalty.\n\nThe Harbor agent container starts with a small Rust skeleton project in\n`/app`. You may use it, modify it, or replace it entirely. You may also use any\nRust crates, internal harness, data structures, and build layout you want, as\nlong as the final project satisfies the judge contract below.\n\nThe judge builds and runs your service with:\n\n```bash\ncargo build --release\nPORT=<port> cargo run --release --quiet\n```\n\nThe Harbor environment uses the Ubuntu `apt` Rust toolchain:\n\n```text\nrustc 1.75\ncargo 1.75\n```\n\nIf you add crates, choose versions compatible with this toolchain or pin\ntransitive dependencies accordingly.\n\nThe service and judge run with the task resource limits below. Design your\nparallel search and indexing strategy for this budget:\n\n```text\nvCPUs: 8\nmemory: 16 GiB\nquery concurrency: 8\ntimed queries per worker: 64\n```\n\nThe service must listen on `PORT` and implement these endpoints:\n\n```text\nPOST /insert\nPOST /bulk_insert\nPOST /search\n```\n\n`/bulk_insert` receives:\n\n```json\n{\"vectors\":[{\"id\":0,\"vector\":[0.1,0.2,...]}]}\n```\n\nand returns:\n\n```json\n{\"status\":\"ok\",\"inserted\":1}\n```\n\n`/search` receives:\n\n```json\n{\"vector\":[0.1,0.2,...],\"top_k\":10}\n```\n\nand returns:\n\n```json\n{\"results\":[{\"id\":0,\"distance\":0.0}]}\n```\n\n## Local Harness\n\nThe official evaluator uses hidden data and a black-box judge. You may call:\n\n```bash\nbash /app/submit.sh\n```\n\nat any time to submit the current `/app` project to the official judge and get\nscore feedback.\n\n## Validity\n\nA submission is valid if:\n\n1. It builds successfully with `cargo build --release`.\n2. `cargo run --release --quiet` starts the service and implements the required HTTP\n   endpoints.\n3. Every returned id is in `[0, 1_000_000)`.\n4. Its `recall@10` is at least `0.95` against the hidden exact top-10 ground\n   truth.\n\n## Scoring\n\nAt trial startup, the Harbor judge sidecar prepares the hidden benchmark and\nruns an exact-search reference HTTP service through the same `/bulk_insert`\nand `/search` client harnesses to produce ground-truth nearest neighbors and\nthe trial-local scoring baseline:\n\n```text\nbaseline_qps\nbaseline_effective_qps\nbaseline_load_seconds\n```\n\nInteractive submissions and the final verifier both score through this same\njudge sidecar, so the baseline and runtime environment are shared within a\ntrial while still letting different machines measure their own local baseline.\n\nEach submission is then timed independently. The load phase includes all\n`/bulk_insert` calls and any index construction performed by the service before\nqueries begin. The query phase uses 8 concurrent workers, each issuing 64\nqueries, and measures only `/search` throughput:\n\n```text\ncandidate_qps\ncandidate_load_seconds\n```\n\nThe reported `qps` is the raw query-only QPS. Scoring uses an effective QPS\nthat includes a small index-build/load penalty:\n\n```text\neffective_qps = Q / (query_seconds + 0.001 * load_seconds)\n```\n\nThe load phase has a default `900s` timeout. This keeps the benchmark focused\non serving performance while still making very expensive offline indexing pay a\nbounded, explicit cost. This relaxed variant makes the load/index-build penalty\nsmall enough that spending additional time on a stronger index can be worthwhile\nwhen it materially improves query throughput or recall.\n\nDuring evaluation, the load and query phases may stop early and return `0` once\nthe elapsed time plus the load penalty makes it impossible for the final\neffective QPS to beat the baseline. During load, this assumes a best-case query\ntime of zero.\n\nIf the submission is invalid, if `recall@10 < 0.95`, or if\n`candidate_effective_qps <= baseline_effective_qps`, the score is `0`.\nOtherwise:\n\n```text\nscore = 100 * (1 - sqrt(baseline_effective_qps) / sqrt(candidate_effective_qps))\n```\n\nThe bounded and unbounded score fields both report this score. Harbor JSON\nresults include the measured `qps`, `effective_qps`, `baseline_qps`,\n`baseline_effective_qps`, `recall_at_10`, load time, and runtime metrics under\nthe `metrics` field.\n", "config": "tag: systems\nruntime:\n  language: rust\n  timeout_seconds: 10800\n  environment: \"Rust project; hidden ANN benchmark; Python/NumPy judge\"\n  apt_packages:\n    - build-essential\n    - cargo\n    - git\n    - rustc\n  judge_apt_packages:\n    - build-essential\n    - cargo\n    - rustc\n    - python3-pip\n    - python3-numpy\n  judge_pip_packages:\n    - faiss-cpu\n  docker:\n    image: ubuntu:24.04\nenvironment:\n  # If these resource limits change, also update the resource budget text in\n  # readme and harbor/app/README.md so agents can design parallel algorithms\n  # for the actual CPU and memory budget.\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\nevaluation:\n  # The judge drives the search service with this many concurrent workers.\n  # Keep this aligned with the CPU budget unless the task is intentionally\n  # changed into a higher-concurrency service benchmark.\n  query_concurrency: 8\n  queries_per_worker: 64\n  # Weight applied to load/index-build time when computing effective QPS.\n  # This relaxed variant rewards stronger indexes by penalizing build time\n  # 10x less than the standard Vector DB ANN task.\n  load_penalty_weight: 0.001\nsubmission:\n  kind: directory\n  path: /app\n  exclude:\n    - target\n    - .git\n    - .frontier-cs\n"}
+{"problem_id": "vllm_llm_serving_optimization", "category": "2.0", "statement": "# vLLM LLM-Serving Latency Optimization\n\n## Problem\n\nThis is an experimental systems task. You are given a pinned, clean checkout of\n[vLLM](https://github.com/vllm-project/vllm) in the Harbor workspace and may\nmodify vLLM itself. Your goal is to reduce the **end-to-end latency** of an LLM\nserving system on a realistic multi-turn agentic workload while preserving the\n**accuracy** (task-solving quality) of the served model.\n\nThe serving target is a deployment of\n`Qwen/Qwen3-Coder-30B-A3B-Instruct` running on one NVIDIA **H100**, exposed\nthrough vLLM's OpenAI-compatible HTTP API. The workload is an agentic\ncode-editing benchmark (see *Workload* below) whose requests are long,\nmulti-turn conversations that arrive over time as a Poisson process.\n\nThe intended optimization area is **online serving efficiency**: request\nscheduling, batching, KV-cache management, prefix/prompt cache reuse,\npreemption and admission control, queueing, and closely related\nscheduler/execution wiring. Strong submissions improve the workload's latency\ndistribution without changing what the model actually generates and without\nhard-coding the benchmark, dataset, queries, or judge details.\n\n## Serving Stack (Modal + H100)\n\nBoth your local public test and the hidden judge serve the patched vLLM the\nsame way:\n\n- A [Modal](https://modal.com/docs) app builds an image from **your patched\n  vLLM source** and serves `Qwen/Qwen3-Coder-30B-A3B-Instruct` on one **H100**\n  through the OpenAI-compatible endpoint (`<url>/v1`).\n- The image is built with `VLLM_USE_PRECOMPILED=1`, which reuses vLLM's\n  prebuilt CUDA kernels and rebuilds only the Python layer. **Your patch must\n  therefore be Python-only** — changes that require recompiling CUDA/C++\n  kernels are out of scope and rejected by the patch policy.\n- The serving runtime (model, GPU, tensor-parallel size, max model length,\n  dtype, and OpenAI server flags) is fixed and identical for the baseline and\n  your patched build. You may not change how the server is launched; you may\n  only change vLLM's internal behavior through allowlisted source files.\n\nRunning the model requires Modal and Hugging Face credentials configured in the\nenvironment (`MODAL_TOKEN_ID`, `MODAL_TOKEN_SECRET`, and an `HF_TOKEN` for model\ndownloads). These are provided to the workspace and the judge; do not attempt to\nread, print, or exfiltrate them.\n\n## Workload\n\nThe judge runs **two** serving workloads against each build and combines them\n**50/50** (see *Scoring*):\n\n**1. SWE-bench agentic (latency-primary).** A\n[mini-swe-agent](https://github.com/SWE-agent/mini-swe-agent)-style SWE-bench\nrun: each instance is one agentic task in which the agent holds a multi-turn\nconversation with the served model, issuing shell commands in a sandboxed\nrepository between turns. Every turn re-sends the growing conversation, so\nconsecutive requests for the same task share a long common prefix. Instances\narrive over time (Poisson arrivals), so many conversations are in flight at once\nand compete for GPU and KV-cache capacity. The dataset is the public\n`princeton-nlp/SWE-bench_Lite` set (split `test`); the agent loop, step\nlimit, and decoding settings (temperature `0`) are fixed.\n\n**2. BFCL memory (agentic, correctness-primary).** The `memory` category of the\n[Berkeley Function Calling Leaderboard](https://gorilla.cs.berkeley.edu/leaderboard.html):\neach instance is a multi-turn agentic task where the model is given a key-value\nmemory tool suite (pre-seeded with facts from a prior conversation), asked a\nquestion, and must issue retrieve/search tool calls across several turns and then\nanswer. Correctness is a deterministic word-boundary match of the final answer\nagainst the ground truth. This gives a real, **non-zero** accuracy signal (and a\nmulti-step request path), so it provides a *live* accuracy guardrail and a\nper-sample correctness check alongside SWE-bench. Instances arrive over time as a\nPoisson process (like the SWE-bench workload), so multiple multi-step memory\nconversations are in flight at once and queue.\n\nTreat both as representative analytical serving workloads, not sets of strings\nto recognize. The hidden judge may include additional non-public instances and\nmay vary instance order and arrival timing. Submissions should implement general\nserving optimizations rather than benchmark-specific special cases.\n\n**Request metadata.** Each request carries a stable per-conversation id in\n`sampling_params.extra_args[\"job_id\"]` (the client sends it via `vllm_xargs`);\nall requests of one benchmark instance share the same value, and vanilla vLLM\nignores it. Any request metadata available on the server is fair game for your\nscheduling logic, but whatever you do must be a general policy — do not key on\nspecific id values or otherwise special-case the benchmark (the patch policy\nforbids it).\n\n## Submission\n\nThe submitted artifact is a patch file:\n\n```text\n/app/solution.patch\n```\n\nThe agent workspace contains a clean vLLM checkout at:\n\n```text\n/app/vllm\n```\n\nAfter modifying vLLM, generate and submit a patch:\n\n```bash\nbash /app/make_submission.sh\nbash /app/submit.sh\n```\n\nSubmissions are asynchronous. Submit an initial small, plausible patch as soon\nas it is generated, then keep iterating while the judge works. The judge applies\nyour patch to a clean pinned vLLM source tree, builds it on Modal, serves it,\nruns the workload, and scores latency and accuracy from the judge side.\nSubmitted binaries, build artifacts, generated benchmark files, and local\ntiming logs are ignored.\n\n## Public Test (async, latency + accuracy feedback)\n\nYou can evaluate your current working tree yourself, without going through the\njudge queue, using the public test client:\n\n```bash\n# Launch an async public-test run (deploys your patched vLLM to Modal H100,\n# runs the public instance subset, returns a run id):\nbash /app/public_test.sh launch\n\n# Poll for the result (latency + accuracy, not just whether it compiled):\nbash /app/public_test.sh status <run_id>\n\n# Or run synchronously:\nbash /app/public_test.sh run\n```\n\nThe public test reports the **same kind of feedback the judge uses**: per-instance\nand aggregate end-to-end latency, an accuracy signal versus the baseline, and a\nprovisional score — not merely whether the build succeeded. The public instance\nsubset is a strict subset of the final evaluation set, so it is a fast, faithful\nproxy. Use it to drive your optimization loop: change vLLM, rerun the public\ntest, read the returned latency/accuracy, and adjust.\n\n## Correctness\n\nCorrectness is a hard gate, applied **before** any timing is scored. The patched\nserver must not change what the model generates at temperature `0`:\n\n- **SWE-bench greedy gate.** The judge runs a fixed greedy-decoding smoke set and\n  requires the patched build's outputs to match the baseline token-for-token.\n- **BFCL per-sample gate.** On the BFCL slice, the patched build must not flip an\n  instance from **correct** (baseline) to wrong/undecodable; a small number of\n  flips is tolerated to absorb rare batch-numerics differences, but a real\n  regression fails the gate.\n\nBuild failures, patch-policy violations, server start-up failures, generation\nmismatches, crashes, timeouts, and out-of-memory failures all score `0` before\nperformance is considered.\n\nDuring iterative asynchronous submissions, the judge keeps feedback focused on\nthe public instance subset so you can submit early and continue working while\nevaluation runs. During final verification, the judge uses the broader hidden\ninstance set.\n\n## Scoring\n\nThe final score blends the two workloads:\n\n```text\nfinal_score = 0.5 * swebench_score + 0.5 * bfcl_score\n```\n\nEach workload is scored by **latency speedup relative to the baseline** (vanilla\nvLLM serving the same model on an H100 under the same workload and arrival\nschedule), gated by an **accuracy guardrail**.\n\nLatency is the end-to-end completion time per instance (first request to last\nresponse), measured client-side. Per-instance speedups are clamped to a bounded\nrange and a patched instance that *fails* (errors / exits early) is counted as a\nregression — so failing fast cannot inflate the score. The per-workload objective\nis the **geometric mean** of those per-instance speedups:\n\n```text\nper_instance_speedup = clip(baseline_latency[i] / patched_latency[i], 1/cap, cap)\nlatency_speedup      = geomean(per_instance_speedup)\nlatency_score        = clip(100 * log2(latency_speedup), 0, 100)\n```\n\nA `1.0x` result earns `0` points and regressions also earn `0`.\n\nEach workload's accuracy gates its latency score. For BFCL this is the\nmemory-retrieval accuracy (a real, non-zero signal); for SWE-bench it is the\ntask-solving proxy. Let\n\n```text\nrel_drop            = max(0, (baseline_accuracy - patched_accuracy) / baseline_accuracy)\naccuracy_multiplier = 1.0              if rel_drop <= 0.05\naccuracy_multiplier = 0.05 / rel_drop  otherwise\nworkload_score      = latency_score * accuracy_multiplier\n```\n\nSo a fast build that meaningfully degrades memory-retrieval quality loses most of\nits BFCL score, while a build that keeps accuracy within 5% of the baseline is\nscored on its latency improvement. The per-workload speedups, accuracies, and\nmultipliers are reported in evaluator metrics.\n\n## Patch Policy\n\nThe evaluator validates the patch before building. The policy is intentionally\nstrict because this task is graded by hidden benchmarks.\n\nAllowed serving/scheduler/execution areas:\n\n```text\nvllm/v1/core/**\nvllm/v1/core/sched/**\nvllm/v1/core/kv_cache_utils.py\nvllm/config/scheduler.py\nvllm/config/cache.py\n```\n\nConditionally allowed narrow wiring areas:\n\n```text\nvllm/v1/worker/**\nvllm/v1/engine/**\nvllm/v1/executor/**\nvllm/v1/request.py\nvllm/v1/outputs.py\nvllm/v1/serial_utils.py\nvllm/entrypoints/openai/protocol.py\nvllm/entrypoints/openai/serving_engine.py\nvllm/entrypoints/openai/serving_chat.py\nvllm/entrypoints/openai/serving_completion.py\nvllm/sampling_params.py\n```\n\nNew Python files are allowed in these areas. The build uses `VLLM_USE_PRECOMPILED`,\nso no build-system, CUDA/C++, packaging, or dependency changes are permitted.\n\nForbidden areas include CUDA/C++ kernels and build files (`csrc/**`, `cmake/**`,\n`CMakeLists.txt`, `setup.py`, `pyproject.toml`, `requirements/**`), tests,\nbenchmarks, docs, examples, CI files, model definitions\n(`vllm/model_executor/models/**`), tokenizer/loader internals, the workload\nharness, and any timing or scoring code.\n\nPatches may not add reads or writes of judge, Modal, Hugging Face, Frontier, or\nHarbor environment variables, and may not hard-code the benchmark name, dataset\nname, instance identifiers, or judge paths in scheduler/execution code. The\nserver is launched under a fixed configuration; patches that detect the\nbenchmark, sleep, short-circuit generation, or otherwise special-case the\nevaluation are rejected.\n\n## Resource Budget\n\nThe experimental Harbor budget is:\n\n```text\nagent/judge container vCPUs: 8\nagent/judge container memory: 32 GiB\nstorage: 64 GiB\nserved model: Qwen/Qwen3-Coder-30B-A3B-Instruct\nserving GPU: 1x NVIDIA H100 (via Modal; the operator may use H100:N for tensor parallelism)\nbuild timeout: 7200 seconds\nper-instance timeout: 1200 seconds\ndecoding: temperature 0, fixed max tokens\n```\n\nThe judge builds and serves both baseline and patched vLLM under the same fixed\nModal configuration and the same OpenAI server flags, then runs the workload\nunder the same arrival schedule before measuring latency and accuracy.\n", "config": "tag: systems\nruntime:\n  language: python\n  timeout_seconds: 21600\n  environment: \"Patched vLLM (v0.11.0) source; Modal H100 GPU serving Qwen3-Coder-30B-A3B-Instruct; two agentic workloads (mini-swe-agent SWE-bench + BFCL memory) scored 50/50; latency-primary judge with a live BFCL accuracy guardrail + greedy/per-sample correctness gates\"\n  apt_packages:\n    - bash\n    - ca-certificates\n    - curl\n    - git\n    - python3\n    - python3-pip\n  judge_apt_packages:\n    - bash\n    - ca-certificates\n    - curl\n    - git\n    - python3\n    - python3-pip\n  judge_pip_packages:\n    - modal\n    - openai\n    - datasets\n    - huggingface-hub\n    - rank-bm25\n  docker:\n    # Experimental local images. Build them with\n    # 2.0/problems/vllm_llm_serving_optimization/docker/build_images.sh before running a\n    # local Harbor trial. Both images need a clean upstream vLLM v0.11.0 checkout\n    # (NOT the continuum fork). The judge image additionally vendors the\n    # mini-swe-agent harness and the latency/accuracy scorer.\n    image: frontiercs/vllm-serving-optimization-agent:experimental-v0.11.1\n    judge_image: frontiercs/vllm-serving-optimization-judge:experimental-v0.11.1\nenvironment:\n  cpus: 8\n  memory_mb: 32768\n  storage_mb: 65536\n  build_timeout_seconds: 7200\nevaluation:\n  # Model + accelerator served on Modal. Qwen3-Coder-30B-A3B (latest Qwen3 coder,\n  # MoE: 30B total / ~3.3B active per token) actually resolves SWE-bench (the 8B\n  # Llama was ~0) and is fast thanks to the sparse MoE. SINGLE H100 on purpose:\n  # the 30B weights (~61GB bf16) leave only ~12-20GB KV (~5 concurrent 32K seqs),\n  # which is exactly the contention this scheduling task needs. H100:2 was measured\n  # to OVER-PROVISION (no queueing -> scheduling can't help -> codex ~1.0x); on one\n  # card the continuum reference wins (SWE ~1.1-1.6x). vLLM TP size is derived from\n  # \"H100:N\". Avoid B200 (sm_100) — the v0.11.0 precompiled wheel has no Blackwell kernels.\n  model: Qwen/Qwen3-Coder-30B-A3B-Instruct\n  gpu: \"H100\"\n  # Workload 1 (latency-primary): mini-swe-agent on SWE-bench Lite (split test).\n  # Lite (300, self-contained) is cheaper/cleaner than Verified; instances are\n  # drawn by a fixed-seed RANDOM sample across all 12 repos (not a sorted prefix,\n  # which clustered into 1-2 hard repos and was unrepresentative).\n  dataset: princeton-nlp/SWE-bench_Lite\n  dataset_split: test\n  # Fixed seed for the deterministic random instance sample (SWE + BFCL), so the\n  # evaluated set is reproducible run-to-run.\n  sample_seed: 20260624\n  # Iterative (agent-role) public test: a strict subset of the final eval set.\n  public_slice: \"0:5\"\n  # Final (verifier-role) evaluation: 50 instances sampled from Lite with\n  # sample_seed (set \"0:300\" for the full Lite split; that is many H100-hours).\n  eval_slice: \"0:50\"\n  # Workload 2 (agentic + real correctness): BFCL **memory** category. Each\n  # instance is a multi-turn agentic task — the model is given a key-value memory\n  # tool suite pre-seeded (vendored snapshots) with facts from a prior\n  # conversation, asked a question, and must issue retrieve/search tool calls\n  # over several turns, then answer (word-boundary match vs ground truth). Gives a\n  # genuine multi-step request path AND a non-zero, non-ceilinged accuracy signal\n  # (a strong model gets ~70-90%, not a pinned 1.0), so the guardrail has range.\n  bfcl_public_slice: \"0:8\"\n  # Full memory verify set: all 155 vendored instances at final.\n  bfcl_eval_slice: \"0:155\"\n  bfcl_max_tokens: 768\n  memory_max_steps: 20\n  # BFCL memory arrives as a seeded Poisson process at its OWN rate (bfcl_jps).\n  # Measured: BFCL's short, 93%-prefix-cacheable requests have NO clean scheduling\n  # signal at any rate. Below KV saturation (jps<=1.0) the metric is reproducible\n  # (~1.0x, identical run-to-run) but flat; at/above saturation (jps>=1.5) a real\n  # ~1.4x job-FCFS effect appears but is swamped by batch-numerics non-determinism\n  # (the SAME patch measured 0.71x and 1.55x across two clean jps=1.5 runs; an\n  # identical-build control swung 10x at jps=2.5). So BFCL runs at jps=1.0 — the\n  # one reproducible point — mainly for its correctness gate + accuracy guardrail,\n  # and is DOWN-WEIGHTED in the latency blend (see *_weight below). SWE carries the\n  # latency signal (its many-turn latency is robust to single-token flips).\n  bfcl_jps: 1.0\n  # bfcl_workers only caps the fallback burst path (arrival_mode != jps).\n  bfcl_workers: 64\n  # Final score = swebench_weight * SWE-bench score + bfcl_weight * BFCL score.\n  # SWE-heavy: SWE carries the reliable latency signal; BFCL is down-weighted to\n  # 0.2 because at its one reproducible load (jps=1.0) it is latency-neutral (~1.0x)\n  # and mainly serves as the correctness gate + accuracy guardrail.\n  swebench_weight: 0.8\n  bfcl_weight: 0.2\n  # Poisson arrival workload (jobs/second). Mirrors a realistic serving load.\n  arrival_mode: jps\n  jps: 0.5\n  workers: 8\n  step_limit: 50\n  temperature: 0.0\n  max_completion_tokens: 2048\n  # Latency aggregation + scoring.\n  latency_metric: mean_e2e_seconds\n  # Per-instance speedup is clamped to [1/cap, cap]; a failed/early-exit patched\n  # instance is counted as a regression, so \"fail fast\" cannot inflate the geomean.\n  max_per_instance_speedup: 8.0\n  # Accuracy guardrail (per workload). Within `accuracy_tolerance` relative drop\n  # of baseline => no penalty; beyond it the score decays inverse-proportionally.\n  # No penalty if the accuracy drop is within EITHER the relative tolerance OR\n  # the absolute tolerance (resolve_rate over a finite slice is coarse/noisy).\n  accuracy_tolerance: 0.05\n  accuracy_abs_tolerance: 0.05\n  agent_accuracy_mode: patch_validity\n  final_accuracy_mode: resolve_rate\n  # Greedy-output correctness smoke (fixed prompts must match the baseline\n  # token-for-token at temperature 0 before timing is considered).\n  correctness_smoke_prompts: 8\n  # BFCL per-sample correctness gate: a temperature-0 patch should not flip BFCL\n  # answers correct->wrong/undecodable. Allowed flips = max(the count floor below,\n  # abs_tolerance * n_instances, rel_tolerance * n_baseline_correct) — a 5%/5%\n  # abs-OR-rel band that absorbs batch-numerics non-determinism (which flips many\n  # instances run-to-run even between identical builds under concurrency).\n  bfcl_max_correctness_regressions: 1\n  bfcl_correctness_abs_tolerance: 0.05\n  bfcl_correctness_tolerance: 0.05\n  # Modal serving knobs.\n  modal_scaledown_seconds: 900\n  modal_startup_timeout_seconds: 1200\n  server_health_timeout_seconds: 1800\n  # Per-phase wall-clock budgets (seconds). Matches the documented build budget.\n  build_timeout_seconds: 7200\n  instance_timeout_seconds: 1200\n  # Use a baseline (vanilla vLLM) cached in the judge image when available,\n  # otherwise the judge serves vanilla once and caches it for the trial.\n  baseline_cache_path: /opt/vllm-baseline/baseline_metrics.json\nsubmission:\n  kind: file\n  path: /app/solution.patch\n  max_queue_size: 2\n"}