Add files using upload-large-folder tool

CITATION.cff

@@ -0,0 +1,50 @@
+cff-version: 1.2.0
+message: If you use AutoResearchExam in your research, please cite this work.
+title: AutoResearchExam
+authors:
+- given-names: Anirudha
+  family-names: Ramesh
+- given-names: Siddartha
+  family-names: Devic
+- given-names: Shivank
+  family-names: Garg
+- given-names: Advait
+  family-names: Parulekar
+- given-names: Drish
+  family-names: Mahnot
+- given-names: Shreyas
+  family-names: Pimpalgaonkar
+- given-names: Vishnu
+  family-names: Suresh
+- given-names: Alex
+  family-names: Dimakis
+- given-names: Maheswaran
+  family-names: Sathiamoorthy
+date-released: '2026-09-09'
+url: https://benchmarks.bespokelabs.ai/autoresearchexam/
+repository-code: https://github.com/bespokelabsai/AutoResearchExam
+preferred-citation:
+  type: generic
+  title: AutoResearchExam
+  authors:
+  - given-names: Anirudha
+    family-names: Ramesh
+  - given-names: Siddartha
+    family-names: Devic
+  - given-names: Shivank
+    family-names: Garg
+  - given-names: Advait
+    family-names: Parulekar
+  - given-names: Drish
+    family-names: Mahnot
+  - given-names: Shreyas
+    family-names: Pimpalgaonkar
+  - given-names: Vishnu
+    family-names: Suresh
+  - given-names: Alex
+    family-names: Dimakis
+  - given-names: Maheswaran
+    family-names: Sathiamoorthy
+  year: 2026
+  month: 9
+  url: https://benchmarks.bespokelabs.ai/autoresearchexam/

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,128 @@
+# AutoResearchExam
+
+This repository contains the 29 tasks from [AutoResearchExam](https://benchmarks.bespokelabs.ai/autoresearchexam/).
+
+## Task areas
+
+```mermaid
+pie showData
+    title Tasks by research area
+    "Model training" : 8
+    "Algorithms and optimization" : 6
+    "Data engineering and curation" : 6
+    "Systems and efficiency" : 4
+    "Evaluation, calibration, and robustness" : 3
+    "AI safety and alignment" : 1
+    "Interpretability" : 1
+```
+
+<details>
+<summary>View tasks by area →</summary>
+
+### Model training
+
+#### Representation learning
+
+- [Compact encoding for a column with many categories](./tasks/hicard-latent-encoder)
+- [Compact item embeddings for recommendations](./tasks/sparse-elsa-item-embeddings-8nnz)
+- [Short binary codes for image search](./tasks/mlh-coco-16bit-hash-head-map5000)
+
+#### Reinforcement learning
+
+- [Advantage estimation for policy training](./tasks/grpo-rl-halfcheetah-advantage-estimator)
+- [Reliable control policy trainer](./tasks/reppo-reliable-onpolicy-control-trainer)
+
+#### Predictive modeling
+
+- [Predict valid actions for a game policy](./tasks/vas-maskless-deployment-feasibility)
+- [Rank employee access requests from ID codes](./tasks/dctabeval-aeac-pooled-cat-statistics)
+
+#### Model merging and distillation
+
+- [Eight domain vision model merging](./tasks/ties-merging-clip-vitl14-eight-task-merge)
+
+### Algorithms and optimization
+
+#### Statistical methods
+
+- [Estimate uncertainty in a streaming optimizer](./tasks/sketched-newton-cov-estimator)
+- [Estimate individual treatment effects](./tasks/causalpfn-cate-pehe-ihdp-surfaceb)
+- [Recover river flow links](./tasks/causalrivers-heldout-station-graph-auroc)
+
+#### Constrained optimization
+
+- [Dual market budgeted classification](./tasks/budgeted-covtype-dual-market-open)
+- [MILP branching policy](./tasks/tgat-milp-branching-node-count)
+- [Online chance constrained policy](./tasks/sopcc-online-chance-constrained-policy)
+
+### Data engineering and curation
+
+#### Imputation
+
+- [Budgeted imputation](./tasks/budgeted-imputation-mcar50)
+- [Sparse panel imputation](./tasks/act-tensor-sparse-panel-imputation-r2)
+
+#### Data selection
+
+- [Unlabeled pool pruning](./tasks/activeprune-al-unlabeled-pool-pruning)
+- [Low discrepancy subset selection](./tasks/carps-star-discrepancy-subset-select)
+- [Group robust coreset selection](./tasks/coreset-selection-group-robust-waterbirds)
+- [Pretraining token budget selection](./tasks/less-is-more-pretrain-token-budget-selector)
+
+### Systems and efficiency
+
+#### Inference
+
+- [CPU language model decoding](./tasks/cpu-llm-decode-throughput)
+- [CPU decoder graph execution](./tasks/cpu-decoder-graph-executor)
+- [Video diffusion transformer caching](./tasks/fastercache-budgeted-video-dit-cache-policy)
+
+#### Compression
+
+- [SVDQuant PixArt Sigma quantization](./tasks/svdquant-w4a4-psnr)
+
+### Evaluation, calibration, and robustness
+
+#### Metric estimation
+
+- [Shortest valid confidence interval](./tasks/shortest-valid-ci-l2-ece)
+- [Label efficient risk estimation](./tasks/label-efficient-risk-estimator)
+
+#### Robustness
+
+- [Adversarially robust CIFAR 10 training](./tasks/fast-adv-budgeted-pgd50-robust-cifar10)
+
+### AI safety and alignment
+
+- [Candidate token loss ranker](./tasks/fastergcg-candidate-token-rank-ccc)
+
+### Interpretability
+
+- [Sparse dictionary coding](./tasks/sae-sparse-dict-nmse-frontier)
+
+</details>
+
+The AutoResearchExam Harness will be open sourced shortly.
+
+## Citation
+
+If you use AutoResearchExam in your research, please cite:
+
+```bibtex
+@misc{ramesh2026autoresearchexam,
+  author = {Ramesh, Anirudha and
+            Devic, Siddartha and
+            Garg, Shivank and
+            Parulekar, Advait and
+            Mahnot, Drish and
+            Pimpalgaonkar, Shreyas and
+            Suresh, Vishnu and
+            Dimakis, Alex and
+            Sathiamoorthy, Maheswaran},
+  title = {{AutoResearchExam}},
+  year = {2026},
+  month = sep,
+  url = {https://benchmarks.bespokelabs.ai/autoresearchexam/},
+  note = {Published September 9, 2026}
+}
+```

citation.bib

@@ -0,0 +1,16 @@
+@misc{ramesh2026autoresearchexam,
+  author = {Ramesh, Anirudha and
+            Devic, Siddartha and
+            Garg, Shivank and
+            Parulekar, Advait and
+            Mahnot, Drish and
+            Pimpalgaonkar, Shreyas and
+            Suresh, Vishnu and
+            Dimakis, Alex and
+            Sathiamoorthy, Maheswaran},
+  title = {{AutoResearchExam}},
+  year = {2026},
+  month = sep,
+  url = {https://benchmarks.bespokelabs.ai/autoresearchexam/},
+  note = {Published September 9, 2026}
+}

tasks/activeprune-al-unlabeled-pool-pruning/README.md

@@ -0,0 +1,5 @@
+# Selecting Useful Documents for Active Learning
+
+*Category: Data engineering and curation. Subcategory: Data selection.*
+
+The agent must help train a positive-versus-negative sentiment classifier using labels for at most 625 of 12,500 documents. Before each of five rounds, the agent narrows the remaining documents to at most 3,125 candidates but does not choose which 125 receive labels. In the first round, the system selects 125 candidates randomly; later, it selects those the current classifier finds most uncertain, meaning its positive and negative predictions are closest to 50–50. The agent can remove irrelevant or repetitive documents while preserving useful, varied examples, adapting its filtering as labels arrive. It is evaluated on separate unseen documents using macro-F1, which gives equal importance to performance on positive and negative sentiment.

tasks/activeprune-al-unlabeled-pool-pruning/instruction.md

@@ -0,0 +1,110 @@
+# Unlabeled-pool pruning for active learning
+
+An active-learning loop trains a binary sentiment classifier over a large unlabeled pool of
+documents. Each round, before the acquisition function runs, your code picks which subset of
+the still-unlabeled documents the acquisition function is allowed to consider. Everything else
+about the loop is fixed and already built for you.
+
+Write `/app/output/prune.py`. Your goal is to push the mean final-iteration macro-F1 as high as
+possible.
+
+Target metric: the mean final-iteration macro-F1 (in percent) on the hidden grading pools'
+evaluation sets, averaged over 24 seeded end-to-end runs.
+
+## The loop, per run
+
+1. `prune` is called and returns at most 3125 pool indices (25% of the 12500-document pool).
+2. The acquisition function picks 125 of the returned documents and reveals their stored
+   labels. On iteration 0 there is no model yet, so it picks the 125 uniformly at random from
+   what you returned. After that, it takes the 125 documents the current model is least
+   confident about, breaking ties by ascending pool index. If you return fewer than 125
+   indices, only that many documents get labelled that round.
+3. The classifier (multinomial logistic regression, `C=1.0`, `lbfgs`, `max_iter=1000`, over
+   fixed 128-dimensional frozen text features) is refit from scratch on every label acquired so
+   far, then scored on a held-out evaluation set.
+
+There are five iterations, so 625 labels at most. The graded number is the arithmetic mean,
+over 24 seeded end-to-end runs, of the macro-F1 in percent the classifier reaches on the
+evaluation set after the fifth iteration. Grading uses pools built by the same procedure as the
+ones you're given, but from disjoint source documents you've never seen.
+
+## The entry point
+
+`/app/output/prune.py` must define, at module top level:
+
+```python
+def prune(pool_texts, available, labeled_indices, labeled_labels,
+          keep, iteration, rng_seed) -> list[int]
+```
+
+- `pool_texts` - the whole pool as a `list[str]` of raw documents, length 12500. The same object
+  is passed on every call within a run.
+- `available` - `list[int]`, the pool indices not yet labelled.
+- `labeled_indices`, `labeled_labels` - `list[int]`, what's been labelled so far in this run and
+  the labels that came back. Both empty on iteration 0.
+- `keep` - `3125`, the largest selection allowed.
+- `iteration` - `0` to `4`.
+- `rng_seed` - this run's seed. Use it if you want your own randomness to be reproducible.
+
+The return value must be a `list`, `tuple`, or 1-D integer numpy array of distinct ints, every
+one present in `available`, with length between `1` and `keep` inclusive. Returning fewer than
+`keep` (pruning harder) is allowed. Order doesn't matter: the simulator sorts the indices and
+treats the result as a set.
+
+The module is imported once per run in a fresh process, so module-level state persists across
+that run's five calls but is discarded before the next run starts.
+
+## Budgets and hard limits
+
+- Module import: 60 s per run. Each `prune` call: 20 s of wall clock.
+- 4 GiB of address space per run. Threading libraries are pinned to one thread; the grading
+  container has 8 vCPUs, 14 GiB of RAM, no GPU, and no network.
+- The 24 runs are independent. Your module gets a read-only copy of the deliverable directory.
+  The only writable path is the private scratch directory named by `TMPDIR` (also `HOME`),
+  which is deleted when the run ends. `/tmp`, `/var/tmp`, and `/dev/shm` are not writable.
+  Nothing you write during scoring survives into another run.
+- Anything else scores 0: no `/app/output/prune.py`, an empty one, an import error, a wrong
+  function name or arity, an exception, a blown budget, a return value of the wrong type or
+  dtype, a duplicate index, an index not in `available`, or a length of 0 or above `keep`. A
+  single failing run invalidates the whole submission.
+- A submission containing a symlink or hard link anywhere under `/app/output` is rejected and
+  scores 0.
+
+## What crosses to the grader
+
+- Only `/app/output/` travels, in its entirety. Every module, model, vocabulary, threshold
+  table, cached statistic, and data file your `prune` loads at grade time must live inside that
+  directory; nothing you write anywhere else survives.
+- Packages available at grade time: `numpy`, `scipy`, `scikit-learn`, `joblib`,
+  `threadpoolctl`, and the standard library.
+- Absent when you're scored: `/app/data/`, `/app/harness/`, and `/app/run_dev.py`. Do not
+  import from them at grade time.
+- Your `prune` receives raw text only. The frozen feature matrices belong to the simulator, not
+  to you.
+
+## What you are given
+
+- `/app/data/pool_{a,b,c}.jsonl.gz` - three development pools, one JSON object per line with
+  `text` and the `label` the oracle would return for it. 12500 lines each.
+- `/app/data/pool_{a,b,c}_X.npy` - the frozen 128-d features for each pool, `float32`, shape
+  `(12500, 128)`; `/app/data/pool_{a,b,c}_y.npy` - the same labels as `int8`.
+- `/app/data/dev_eval.jsonl.gz`, `/app/data/dev_eval_y.npy`, `/app/data/eval_a_X.npy`,
+  `/app/data/eval_b_X.npy`, `/app/data/eval_c_X.npy` - a development evaluation slice of 2500
+  held-out labelled documents and its features under each pool's feature map.
+- `/app/harness/al_loop.py` - the simulator, byte-identical to the one that scores you, plus the
+  process isolation and budget enforcement it runs under.
+- `/app/run_dev.py` - runs the loop end to end on the development pools with your pruner and
+  prints per-pool and overall means:
+
+  ```
+  python3 /app/run_dev.py --draws a,b,c --seeds 0-11
+  ```
+
+The simulator, the acquisition function, the classifier, and the evaluation are all fixed. The
+grader uses its own copies, so editing anything under `/app/harness/` changes nothing about how
+you're scored.
+
+## Scoring
+
+A mean final-iteration macro-F1 of 77.9 percent or lower scores 0. Above that floor, every
+improvement receives a higher score.

tasks/activeprune-al-unlabeled-pool-pruning/task.toml

@@ -0,0 +1,57 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/activeprune-al-unlabeled-pool-pruning"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Machine Learning and AI"
+subcategory = "Data Engineering and Curation"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program",]
+expert_time_estimate_hours = 4.0
+
+[verifier]
+timeout_sec = 1800.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+user = "agent"
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/budgeted-imputation-mcar50/README.md

@@ -0,0 +1,5 @@
+# High throughput data imputation
+
+*Category: Data engineering and curation. Subcategory: Imputation.*
+
+The task consists of several incomplete numeric training and evaluation tables with up to 42 columns and 10,000 training rows. Half of the values are hidden at random. The objective is to fill in the missing values in evaluation tables within a 30 second time limit. Different datasets can contain different patterns between columns, so the method must find useful patterns without seeing any complete table. One may start by filling each missing value with its column mean or a prediction from the other columns. Further gains may come from repeated prediction and methods that learn shared structure across rows and columns.

tasks/budgeted-imputation-mcar50/instruction.md

@@ -0,0 +1,77 @@
+# Recovering missing values under 50% missingness, on a fixed CPU budget
+
+Fill in the missing values in unseen numeric tables as accurately as possible.
+Each value is missing independently with 50% probability, and each call has a 30 second
+wall clock limit.
+
+Write an imputer at `/app/output/impute.py`.
+
+## Submission format
+
+- File: `/app/output/impute.py`.
+- It must define exactly this function:
+
+```python
+def impute(X_train: np.ndarray, X_eval: np.ndarray, seed: int) -> np.ndarray
+```
+
+- One call handles one dataset.
+- `X_train`: shape `(n_train, d)`, dtype float64.
+- `X_eval`: shape `(n_eval, d)`, dtype float64.
+- `X_train` and `X_eval` are row-disjoint samples from the same numeric tabular dataset.
+- Both matrices have `np.nan` at their missing entries.
+- Missingness is MCAR at a rate of 0.50, drawn independently for each matrix.
+- Features were transformed to a normal output distribution by a quantile transform fitted on the incomplete training matrix.
+- `seed`: an integer you may use for any randomness you need.
+- Nothing in the two matrices reveals the true value of a missing entry.
+
+Return value:
+
+- The completed evaluation matrix.
+- Must be a `numpy.float64` array, or something `numpy.asarray` can convert to one.
+- Shape `(n_eval, d)`, with row `i` and column `j` aligned to row `i` and column `j` of `X_eval`.
+- Every entry must be finite: no `nan`, no `+inf`/`-inf`.
+- Only entries that were missing in `X_eval` are scored.
+- A return value with the wrong shape or dtype, or containing a `nan` or an infinity, invalidates the call (see "Execution and budget" for the consequence).
+
+## Metric
+
+- Target metric: imputation $R^2$, computed on hidden evaluation datasets not included in this container (see "Execution and budget").
+- For each call and feature $j$, over that feature's masked evaluation entries:
+
+$$R^2_j = 1 - \frac{\sum_{\text{masked}} (\text{true} - \text{returned})^2}{\sum_{\text{masked}} (\text{true} - \overline{\text{true}})^2}$$
+
+- $\overline{\text{true}}$ is the mean of the true values over the same masked entries.
+- Skip features with fewer than two masked entries, or where the masked true values' sum of squared deviations from their mean is at most 1e-12.
+- Call score: unweighted mean of $R^2_j$ over the remaining features. $R^2$ can be negative.
+- Reported metric: that score averaged unweighted, first over several independent mask draws per dataset, then over all evaluation datasets.
+- Filling every missing entry with the mean of that column's observed training values scores 0.
+- Anything strictly better scores strictly higher, with no ceiling, so keep pushing the metric up.
+
+## Execution and budget
+
+- Each call runs in a fresh process that imports your module and passes it matrices from a tabular dataset not present in this container.
+- Time budget: 30 seconds of wall clock per call, covering interpreter start-up, importing your module, and the `impute` call together.
+- The process is SIGKILLed at 30 seconds.
+- These threading env vars are fixed to `1` in that process: `OMP_NUM_THREADS`, `MKL_NUM_THREADS`, `OPENBLAS_NUM_THREADS`, `NUMEXPR_NUM_THREADS`, `VECLIB_MAXIMUM_THREADS`.
+- A call that overruns the budget, raises an error, or returns something the contract above rejects scores 0 (the column-mean score) for that call.
+- Each call gets a fresh working directory, `HOME`, and `TMPDIR`. Anything it leaves elsewhere is removed before the next call starts, so nothing survives between calls.
+- The 30 seconds are per call and cannot be banked or carried over.
+- Evaluation matrix sizes: `n_train` up to 10000, `n_eval` up to 2500, `d` up to 42 (as low as 3 on some datasets).
+
+## What is here
+
+- `/app/data/dev/`: six complete numeric tabular datasets as `.npz` files, plus `manifest.json` describing each one. These are development material only; none is an evaluation dataset.
+- `/app/cellspec.py`: provides `build_cell(X, seed, n_train, n_eval)`, which builds `(X_train, X_eval, X_eval_true, mask_eval)` from a complete matrix using the row split, MCAR masks, and quantile transform described above. Also provides `imputation_r2(pred, true, mask)`, the metric function. The evaluation harness uses this same file to build its cells.
+- `/app/cellrunner.py`: loads one call's inputs, imports `impute.py`, and saves what it returns. The evaluation harness runs this same file.
+- `/app/devkit.py`: runs `/app/output/impute.py` over the development panel under the same 30-second budget and prints per-draw, per-dataset, and panel scores. Run `python3 /app/devkit.py --list` to show the panel.
+- `/app/output/impute.py` currently contains column-mean imputation.
+
+## Constraints
+
+- Only `/app/output/` is collected for evaluation.
+- Anything your module imports or loads at evaluation time must live under `/app/output/`.
+- Limits under `/app/output/`: at most 2000 files and 512 MB total.
+- Symbolic links under `/app/output/` are not copied.
+- No network access.
+- Container resources: 8 CPUs, 14 GB memory, 0 GPUs.

tasks/budgeted-imputation-mcar50/task.toml

@@ -0,0 +1,52 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/budgeted-imputation-mcar50"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Machine Learning and AI"
+subcategory = "Feature engineering"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program",]
+expert_time_estimate_hours = 4.0
+
+[verifier]
+timeout_sec = 1800.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 600.0
+os = "linux"
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/carps-star-discrepancy-subset-select/README.md

@@ -0,0 +1,5 @@
+# Select points that cover a cube evenly
+
+*Category: Data engineering and curation. Subcategory: Data selection.*
+
+The agent receives between 800 and 4,000 candidate points inside a three-dimensional cube and must directly select exactly 30, 50, or 65 of them within ten seconds. The goal is to distribute the selected points evenly throughout the cube. Evenness is measured using star discrepancy: for every rectangular region extending from the cube’s origin, the evaluator compares the region’s share of the cube’s volume with the share of selected points it contains. For example, a region occupying one quarter of the cube should contain roughly one quarter of the selected points. The largest mismatch across all such regions is the discrepancy. The agent may use spatial grids, greedy selection, local point swaps, random restarts, or fast approximations of this worst mismatch. It is evaluated on unseen point clouds using mean exact star discrepancy; lower is better, and a random subset is the baseline.

tasks/carps-star-discrepancy-subset-select/instruction.md

@@ -0,0 +1,63 @@
+# Low-discrepancy subset selection
+
+You get a cloud of `n` points in the unit cube `[0,1]^3` and a subset size `k`. Return the `k`
+points that fill the cube most evenly, in the L-infinity star discrepancy sense.
+
+For a set `P` of `k` points, the star discrepancy is:
+
+$$d^*(P) = \sup_{q \in [0,1]^3} \left| \frac{\#\{p \in P : p < q\}}{k} - q_1 q_2 q_3 \right|$$
+
+This is the worst gap, over every box `[0,q)` anchored at the origin, between the fraction of `P`
+inside the box and the box's volume. Lower is better.
+
+## Submission format
+
+Write `/app/output/select_subset.py`, defining exactly one entry point:
+
+```python
+select(points, k, seed, time_budget_s) -> sequence of k ints
+```
+
+- `points`: C-contiguous float64 array, shape `(n, 3)`, values in `[0, 1]`, `800 <= n <= 4000`.
+- `k`: int, one of `30`, `50`, `65`; always `k < n`.
+- `seed`: int. Use it for any randomness so a call is reproducible.
+- `time_budget_s`: float, `10.0` at grade time. `select` must return within it.
+- Return value: any iterable of exactly `k` distinct integer indices into `points`, each in
+  `[0, n)`. Values can be Python ints, numpy integers, or floats with an integral value.
+
+## Data notes
+
+- Example clouds live in `/app/data/examples/`.
+- `/app/data/examples/manifest.json` lists each cloud's file name, `n`, and `k`.
+- Grading uses sealed clouds drawn the same way; your code sees them for the first time at grade
+  time.
+
+## Metric and scoring
+
+- `select` is called once per (cloud, seed) pair.
+- You're scored on the mean exact `d*` of the returned subsets across the whole panel.
+- A subset no better than an unguided, uniformly random `k`-subset scores zero.
+- Lower discrepancy always scores higher, with no cutoff where further improvement stops
+  counting.
+
+## Execution environment
+
+- Grading runs in a separate environment from this one, and only `/app/output` carries over. So
+  your solution must be fully self-contained there: if `select_subset.py` imports a helper module
+  you wrote, that module must also live under `/app/output`.
+- Each call runs in a fresh process pinned to a single CPU.
+- `/app/output` is mounted read-only at grade time. A scratch working directory is provided and
+  deleted after each call, so nothing written during one call is visible to any other.
+- The process is SIGKILLed `time_budget_s + 5` seconds after it starts. Interpreter startup and
+  importing your module count against that extra 5 seconds.
+- Available packages: the Python standard library, numpy, and scipy. No network access.
+- `/app/output` is writable now; everything else is read-only.
+- Everything under `/app/output` must be a regular file. A symbolic or hard link anywhere in that
+  tree makes the whole submission unscoreable.
+
+## Invalid submissions
+
+- If a call is killed, raises, or returns anything other than exactly `k` distinct in-range
+  integral indices, that cloud is scored as if no subset had been selected, the worst credit
+  available.
+- If your module fails to import, you score zero overall.

tasks/carps-star-discrepancy-subset-select/task.toml

@@ -0,0 +1,53 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/carps-star-discrepancy-subset-select"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Model Training and ML Infrastructure"
+subcategory = "Evaluation infrastructure"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program",]
+expert_time_estimate_hours = 3.0
+
+[verifier]
+timeout_sec = 1200.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 600.0
+os = "linux"
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+user = "agent"
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/causalrivers-heldout-station-graph-auroc/README.md

@@ -0,0 +1,5 @@
+# Recovering River Networks from Flow Measurements
+
+*Category: Algorithms and optimization. Subcategory: Statistical methods.*
+
+The agent must infer how five river-monitoring stations are connected using five years of discharge measurements recorded every 15 minutes. A directed connection from station A to station B means water passes from A to B without another monitored station between them. The station names, locations, and ordering are hidden, so the agent must assign a likelihood score to each of the 20 possible directed connections. A useful signal is that a change in flow upstream may appear downstream after a delay, although shared seasons can make unrelated stations move together, while missing or faulty readings add noise. The agent may clean the data, remove seasonal patterns, measure delayed relationships, test whether a connection remains after accounting for other stations, and enforce a consistent overall river graph. It is evaluated on 500 unseen five-station networks using AUROC, which measures how reliably true connections rank above false ones; higher is better.

tasks/causalrivers-heldout-station-graph-auroc/instruction.md

@@ -0,0 +1,82 @@
+# Directed edge scores for river gauge subgraphs
+
+A river gauge network is a directed graph over discharge measuring stations. An edge `i -> j`
+means water measured at station `i` flows onward to station `j`, with no gauged station in
+between. Given five years of discharge data from five stations at a time, score how likely each
+ordered pair is to be such an edge.
+
+## Submission format
+
+- Write `/app/output/predict.py` defining a function `score_edges(series, freq_minutes) ->
+  numpy.ndarray`.
+- `series`: a C-contiguous `float32` array of shape `(175296, 5)`, 15-minute samples from
+  2019-01-01 00:00 to 2023-12-31 23:45, raw discharge in $m^3/s$.
+- Missing measurements are `NaN` (a few per cent overall, ranging from 0% to 66% for an
+  individual station). A handful of readings are physically impossible negatives.
+- `freq_minutes` is the int `15`.
+- The column order of `series` is a random permutation of the five stations. No identifier,
+  coordinate, river name, or other ordering hint is passed.
+- Return a `(5, 5)` array of real numbers. Entry `(i, j)` scores the hypothesis "column `i` is
+  directly upstream of column `j`" - higher means more likely.
+- Every off-diagonal entry must be finite. The diagonal is ignored. Only the ranking induced by
+  the 20 off-diagonal entries is read, so any scale or offset works.
+
+## Metric
+
+- Each graded sample is a connected 5-node induced subgraph of a held-out gauge network.
+- Its 20 off-diagonal scores are ranked against the true directed edges of that subgraph, using
+  a tie-aware AUROC (self-links excluded, so a constant matrix scores 0.5).
+- The task metric is the unweighted mean of that AUROC over the graded samples.
+- Objective: maximize. Higher is strictly better, with no threshold or cutoff past which further
+  improvement stops counting.
+- A submission no better than cheap heuristic baselines earns 0 reward; reward rises strictly
+  with the metric above that.
+
+## Packages
+
+numpy, pandas, scipy, scikit-learn, statsmodels, networkx and torch (CPU build) are installed
+and importable in both the development and the graded environment. No other packages and no
+network access are available.
+
+## Development data
+
+`/app/data` holds two labelled gauge networks. Their stations are disjoint from each other and
+from the graded stations, and each region is gauged by a different set of agencies.
+
+| file | contents |
+| --- | --- |
+| `/app/data/dev_a_series.npy` | float32 `(175296, 494)`, same time axis, units and defects as `series` |
+| `/app/data/dev_a_edges.csv` | `cause,effect` - column indices of the 490 true directed edges of region a |
+| `/app/data/dev_b_series.npy` | float32 `(175296, 259)` |
+| `/app/data/dev_b_edges.csv` | the 200 true directed edges of region b |
+
+- Each edge list is the induced graph over the stations of its own region: a pair absent from
+  the list has no edge between those two stations.
+- `/app/dev_data.py` has loaders.
+- Nothing in this container describes the graded stations.
+
+## Graded run
+
+- 500 samples per graded run, in groups of at most 40. Each group runs in a fresh process that
+  imports `/app/output/predict.py` once, then calls `score_edges` once per sample in that group.
+  Nothing kept in module state or on disk carries across groups.
+- The whole graded run (every import plus every call) must finish inside 1200 s of wall clock.
+  Overrunning that scores 0.
+- Hardware: 8 vCPUs, 14 GB RAM, 0 GPUs, no network. `OMP_NUM_THREADS`, `MKL_NUM_THREADS`,
+  `OPENBLAS_NUM_THREADS` and `NUMEXPR_NUM_THREADS` are all `1` in the graded process, and
+  `torch.set_num_threads(1)` is called before your module is imported.
+- Grading runs in a separate environment from this one: `/app/output` is the only artifact that
+  crosses over, so the solution must be self-contained inside it. Nothing else in this
+  container - files elsewhere, installed state, anything not under `/app/output` - is available
+  when grading runs.
+- `/app/output` is copied to a directory the graded process can read but not write, and its
+  contents must total at most 50 MB.
+- Modules and data files shipped next to `predict.py` can be imported and read normally; that
+  directory is on `sys.path`. Symbolic links are not carried across the copy.
+- The only writable location during grading is `$TMPDIR`, which is empty at the start of every
+  group.
+- Scoring 0 for the whole run: a missing, empty or unimportable `predict.py`, a missing or
+  non-callable `score_edges`, a group process that dies, or an overrun time budget.
+- Scoring 0.0 for a single sample: a call that raises, or that returns anything other than a
+  `(5, 5)` matrix with finite off-diagonal entries.
+- No network access is available at any point, in either environment.

tasks/causalrivers-heldout-station-graph-auroc/task.toml

@@ -0,0 +1,59 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/causalrivers-heldout-station-graph-auroc"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Machine Learning and AI"
+subcategory = "Model inference and prediction"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program",]
+expert_time_estimate_hours = 6.0
+metric_name = "Mean per-subgraph AUROC of directed-edge scores over a sealed panel of connected 5-node gauge subgraphs"
+objective = "maximize"
+
+[verifier]
+timeout_sec = 2700.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+user = "agent"
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/coreset-selection-group-robust-waterbirds/README.md

@@ -0,0 +1,5 @@
+# Selecting Bird Images Across Hidden Background Groups
+
+*Category: Data engineering and curation. Subcategory: Data selection.*
+
+The agent must choose 240 bird images from a pool of roughly 2,000 to train a fixed classifier that distinguishes two bird classes. It sees each image’s 512-dimensional numerical representation and bird label, but not its background type. This matters because bird class and background are strongly correlated: for example, most waterbirds may appear over water, so a classifier can learn the background instead of the bird and then fail on a waterbird photographed on land. The agent must select exactly 120 examples from each bird class, while trying to include both common and rare background combinations. It may use clustering, diversity selection, class-prediction errors, or low-confidence examples to infer the hidden groups. A fixed logistic-regression classifier is then trained only on the selected images. Evaluation covers 35 runs on unseen pools and measures accuracy on the weakest of the four bird-class-and-background groups; higher is better.

tasks/coreset-selection-group-robust-waterbirds/instruction.md

@@ -0,0 +1,79 @@
+# Coreset selection against an unlabeled slice
+
+You're given embeddings for a pool of bird photos, produced once by a frozen image backbone.
+Each embedding is 512-dimensional. Your job is to pick 240 of these rows to form the training
+set for a fixed downstream classifier.
+
+The classifier is scored on a held-out evaluation set split into four slices: the two class
+labels crossed with a binary attribute. That attribute is never disclosed and never labeled
+anywhere in the material you're given.
+
+## Data provided
+
+| path | contents |
+|---|---|
+| `/app/data/dev_pool_features.npy` | `float32`, shape `(2397, 512)`, development pool embeddings, not L2-normalized |
+| `/app/data/dev_pool_labels.npy` | `int64` in `{0, 1}`, shape `(2397,)`, row-aligned to the features |
+| `/app/data/dev_draws.npy` | `int64`, shape `(4, 2038)`, four subsamples of the development pool, drawn by the same stratified procedure used for the pools you'll be graded on |
+
+These files are read-only. You may only write to `/app/output/`.
+
+## Deliverable
+
+Write `/app/output/selector.py`, with exactly one entry point:
+
+```python
+def select_coreset(features, labels, budget, seed):
+    ...
+```
+
+Contract:
+
+- `features`: `float32` array of shape `(N, 512)`, embeddings of a graded pool you've never
+  seen, from the same backbone as the development pool. `N` is roughly 2000.
+- `labels`: `int64` array of shape `(N,)`, values in `{0, 1}`, row-aligned to `features`.
+- `budget`: `int`, always `240`.
+- `seed`: `int`, yours to use for any randomness of your own.
+- Returns: an `int64` array of shape `(240,)` with **unique** indices in `[0, N)`, of which
+  **exactly 120 have label 0 and exactly 120 have label 1**.
+
+Helper modules can live beside `selector.py` in `/app/output/`. Everything in that directory
+travels with the entry point at grading time, so anything your entry point loads at call time
+needs to be there too.
+
+## Runtime constraints
+
+- Your function is called once per graded pool draw, with 150 seconds of wall-clock time per
+  call.
+- Runs as an unprivileged user: no network, no access to the evaluation set, no attribute
+  labels.
+- Runs with `OMP_NUM_THREADS=1`, on a machine with 8 CPUs, 14336 MB of memory, and 0 GPUs.
+- Available packages: `numpy`, `scipy`, `scikit-learn`. Nothing else is added at grading time.
+- A call that raises an exception, exceeds the time budget, or returns anything that violates
+  the contract above scores zero for the whole submission.
+- A missing or unimportable `/app/output/selector.py` also scores zero for the whole
+  submission.
+
+## The fixed downstream classifier
+
+You cannot change it, and it is not shipped to you. On each graded pool draw, it:
+
+- Trains only on your selected rows.
+- Standardizes those rows by their own per-dimension mean and standard deviation, flooring any
+  standard deviation below `1e-6` to `1e-6` before dividing.
+- Fits a two-class multinomial logistic regression from a seeded initialization: weights drawn
+  i.i.d. from a zero-mean normal distribution with standard deviation `0.01`, biases starting
+  at zero.
+- Trains for 100 epochs of mini-batch SGD: batch size 32, learning rate 0.05, momentum 0.9,
+  weight decay 1e-4, data shuffled each epoch.
+- Applies the trained classifier to the evaluation embeddings.
+
+## Metric
+
+- Each run's score is the classifier's accuracy, in percent, on the weakest of the four slices
+  described above.
+- The submission's score is the mean of that worst-slice accuracy over 7 x 5 = 35 runs (seven
+  graded pool draws, five pinned classifier seeds), in percent.
+- Above a floor set a small margin above the trivial baselines, higher is strictly better, with
+  no ceiling where further improvement stops mattering.
+- A uniform random class-balanced draw scores zero, as does any selection up to that floor.

tasks/coreset-selection-group-robust-waterbirds/task.toml

@@ -0,0 +1,57 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/coreset-selection-group-robust-waterbirds"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Model Training and ML Infrastructure"
+subcategory = "Data loading and training pipelines"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program",]
+expert_time_estimate_hours = 4.0
+
+[verifier]
+timeout_sec = 2400.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+user = "agent"
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/cpu-decoder-graph-executor/README.md

@@ -0,0 +1,5 @@
+# Accelerating transformer decoder graphs on CPUs
+
+*Category: Systems and efficiency. Subcategory: Inference.*
+
+The agent must build a CPU executor for transformer decoder graphs that produces nearly the same hidden states as a fixed reference implementation but runs faster. For each graph and set of weights, it returns a function that will process many new input sequences using those same weights. The graph specifies the decoder's operations, including normalization, attention, position encoding, and feed-forward layers; the agent may change how those operations are scheduled or combined, but it cannot omit required computation, and every output must remain within strict numerical error limits. It may precompute values derived from fixed weights, fuse neighboring operations, reuse memory buffers, call efficient matrix routines, and specialize separate paths for single-token and multi-token inputs. The evaluator times both executors head-to-head on unseen graph shapes. The score is the geometric mean of the reference runtime divided by the submitted runtime, so larger speedups are better; one inaccurate instance makes the submission score zero.

tasks/cpu-decoder-graph-executor/instruction.md

@@ -0,0 +1,109 @@
+# A faster executor for transformer-decoder compute graphs
+
+`/app/reference_executor.py` runs transformer-decoder compute graphs on CPU. Write an
+executor that computes the same thing faster.
+
+## Submission format
+
+- Deliverable: `/app/output/executor.py`, plus any helper modules placed beside it in
+  `/app/output/`.
+- Only `/app/output/` is collected and graded. Everything else under `/app` is reference
+  material. Grading happens in a separate environment, so your submission must be
+  self-contained inside `/app/output/`. Other paths, running processes, and environment
+  state do not carry over.
+- It must expose exactly one entry point:
+
+```python
+build_executor(graph_spec: dict,
+               weights: dict[str, numpy.ndarray],
+               n_workers: int) -> Callable[[numpy.ndarray], numpy.ndarray]
+```
+
+- The returned callable takes `x` of shape `(T, d_model)`, dtype float32, and returns the
+  final hidden states of shape `(T, d_model)`, dtype float32.
+- It will be called many times with different inputs but the same weights.
+
+## Data notes
+
+- `graph_spec` describes a decoder stack. It contains `n_layers`, `d_model`, `d_ff`,
+  `n_heads`, `n_kv_heads`, `head_dim`, `T`, `rms_eps`, a per-layer list of nodes, and a
+  final node. Each node has an operation, named inputs, an output name, and a weight name.
+- `weights` maps every weight name in the spec to a C-contiguous float32 array, plus
+  `rope_cos`, `rope_sin` and `attn_mask`.
+- `n_workers` is `8`.
+
+`/app/reference_executor.py` defines what a correct forward pass is: its module docstring
+states the semantics of every node type, and its code is the tie-breaker if anything is
+ambiguous. Read it. `/app/graph_spec.py` builds instances and their weights from an
+integer seed.
+
+## Correctness
+
+For every call, output `y` is compared against the reference's `y_ref` on the same input.
+Both bounds must hold:
+
+$$\max(|y - y_{ref}|) \le 10^{-3}$$
+
+$$\frac{\lVert y - y_{ref} \rVert_F}{\lVert y_{ref} \rVert_F} \le 10^{-3}$$
+
+- Reassociating a reduction (changing accumulation order) is fine; dropping work is not.
+- A single instance that violates either bound scores the whole submission 0.
+
+## How you are measured
+
+- Your executor and the reference are built for the same instance in two separate
+  processes, then timed head to head.
+- The two are called alternately with a fresh input each repetition. Whichever one isn't
+  being called is suspended so it can't consume cycles, and which one goes first
+  alternates between repetitions.
+- 3 warmup repetitions are discarded.
+- Instance time = fastest of 15 timed repetitions.
+- Instance speedup = `reference_time / your_time`.
+- Score = geometric mean of the per-instance speedups over a sealed set of instances,
+  built from seeds you've never seen, drawn from the ranges below.
+- Maximize this geometric-mean speedup on the sealed set. An executor that just delegates
+  to the reference scores zero; any larger speedup scores higher, with no ceiling where
+  further improvement stops counting.
+
+The sealed instances use the same generator and ranges as the public ones:
+
+| | |
+|---|---|
+| `d_model` | 192, 256 or 384 |
+| `d_ff / d_model` | 2.6875 or 4.0, rounded to a multiple of 32 |
+| `n_layers` | 16 or 32 |
+| `n_heads` | 4 or 8, `head_dim = d_model // n_heads` |
+| `n_kv_heads` | `n_heads`, `n_heads // 2` or `n_heads // 4` |
+| `T` | 1, 8 or 32, with 1 drawn half the time |
+
+## Budget and environment
+
+- `build_executor` must return within **20 seconds** per instance. Each call to the returned
+  callable must finish within **120 seconds**. Time spent in `build_executor` is not included
+  in the runtime metric.
+- The container has **8 CPUs**, **14 GiB** of memory, **0 GPUs** and no network. Each
+  executor process is pinned to 8 CPUs and starts with
+  `OPENBLAS_NUM_THREADS=OMP_NUM_THREADS=MKL_NUM_THREADS=NUMEXPR_NUM_THREADS=8`. The only
+  third-party Python packages installed are `numpy` and `threadpoolctl`.
+- Threads are yours to use, and so are helper processes, but the harness suspends your
+  whole process tree whenever the reference is on the clock, and a process that detaches
+  from that tree stays suspended for good.
+
+## Developing
+
+`python3 /app/bench.py` measures whatever is in `/app/output/` against the reference on
+the 16 public instances (seeds 0-15). It uses the same protocol, tolerances, and worker
+budget as the sealed run. It prints per-instance times, ratios, equivalence errors, and
+the geometric mean. `python3 /app/bench.py --seeds 0,4,9` restricts it to those seeds.
+Public instances are for development only; nothing about them is graded.
+
+A submission scores 0 if any of the following holds:
+
+- `/app/output/executor.py` is missing.
+- It fails to import.
+- It has the wrong signature.
+- It raises.
+- It exceeds a budget.
+- It returns the wrong shape or dtype.
+- It returns values that are not finite.
+- It violates either equivalence bound on any instance.

tasks/cpu-decoder-graph-executor/task.toml

@@ -0,0 +1,57 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/cpu-decoder-graph-executor"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Model Training and ML Infrastructure"
+subcategory = "Systems and Efficiency"
+task_objective = [ "Optimize", "Implement",]
+artifact_type = [ "Single script or program", "Codebase",]
+expert_time_estimate_hours = 4.0
+
+[verifier]
+timeout_sec = 1800.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+user = "agent"
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/fast-adv-budgeted-pgd50-robust-cifar10/README.md

@@ -0,0 +1,5 @@
+# Training a Robust Image Classifier in Three Minutes
+
+*Category: Evaluation, calibration, and robustness. Subcategory: Robustness.*
+
+The agent must write a training program that fits a fixed PreActResNet18 image classifier on 50,000 CIFAR-10 images and saves its weights within 180 seconds. The objective is not ordinary accuracy, but resistance to adversarial examples: test images whose pixels are repeatedly adjusted by tiny amounts to make the classifier choose the wrong class. The fixed evaluator applies a strong 50-step PGD attack, with ten attempts per image and a maximum pixel change of 8/255, then measures how many unseen images remain correctly classified. The agent may use adversarial training, where similarly attacked images are generated during training, along with efficient data augmentation, mixed-precision computation, learning-rate schedules, and a switch from cheap one-step attacks to stronger multi-step attacks. The main trade-off is attack quality versus the number of training updates possible in three minutes. Performance is measured by robust accuracy after the fixed attack; higher is better, while clean accuracy does not affect the score.

tasks/fast-adv-budgeted-pgd50-robust-cifar10/instruction.md

@@ -0,0 +1,44 @@
+# Train an adversarially robust CIFAR 10 model
+
+Train a `PreActResNet18` within 180 seconds. The grader attacks the trained model and measures how many unseen CIFAR 10 images remain correctly classified.
+
+## Deliverable
+
+Write `/app/output/train.py`. It must be a single Python file no larger than 102,400 bytes.
+
+The grader runs:
+
+```text
+python train.py --data /app/data/cifar10_train.npz --out <scratch>/model.pt
+```
+
+Your program must save a PyTorch `state_dict` at the `--out` path. The file must be no larger than 200 MiB. The grader loads it into its own `PreActResNet18()` using `strict=True`. It grades the latest complete checkpoint present when the 180 second limit ends.
+
+Only `/app/output/train.py` moves to the grading environment. The grader places `preact_resnet.py` beside it before running the program.
+
+## Training data
+
+`/app/data/cifar10_train.npz` contains the CIFAR 10 training split:
+
+* `images`: `uint8` with shape `(50000, 32, 32, 3)` in RGB order.
+* `labels`: `int64` with shape `(50000,)` and values from `0` to `9`.
+
+You may choose how to form a validation set from this data. The unseen evaluation images are not available during training.
+
+## Scoring
+
+The target metric is robust accuracy under a fixed PGD 50 attack with perturbation size `8/255`. Higher is better.
+
+The attack uses 50 steps, step size `2/255`, and 10 random restarts. Images use CIFAR 10 channel means `(0.4914, 0.4822, 0.4465)` and standard deviations `(0.2471, 0.2435, 0.2616)`. The attack runs in float32 and uses a fixed random seed.
+
+Before the attack, the grader divides logits by `T = max(1, s / 20)`, where `s` is their mean standard deviation across clean evaluation images. This leaves clean predictions unchanged and prevents logit scaling from weakening the attack.
+
+The score reported during research iterations uses a validation half of the CIFAR 10 test split. The final score uses a separate hidden half. Clean accuracy is recorded but does not affect the reward.
+
+Every increase in robust accuracy receives a higher reward. A missing or invalid checkpoint, incompatible state dictionary, nonfinite weights, input independent model, crash, or timeout receives zero.
+
+## Runtime
+
+The full program, including imports, data loading, training, and checkpoint writing, has 180 seconds of wall clock time.
+
+The environment has one H100 GPU, 4 physical CPU cores, 16,384 MiB of memory, and no general internet access. PyTorch 2.10 with CUDA 12.8 is installed.

tasks/fast-adv-budgeted-pgd50-robust-cifar10/task.toml

@@ -0,0 +1,48 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/fast-adv-budgeted-pgd50-robust-cifar10"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Model Training and ML Infrastructure"
+subcategory = "Training loops"
+task_objective = [ "Implement", "Optimize", "Secure or harden",]
+artifact_type = [ "Single script or program", "Generated output artifact",]
+expert_time_estimate_hours = 4.0
+metric_name = "PGD-50 robust accuracy (percent) on the sealed 10,000-image CIFAR-10 test split at eps=8/255"
+metric_objective = "maximize"
+
+[verifier]
+network_mode = "no-network"
+timeout_sec = 7200.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 21600.0
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 14400.0
+os = "linux"
+cpus = 4
+memory_mb = 16384
+storage_mb = 307200
+gpus = 1
+gpu_types = [ "H100",]
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/fastergcg-candidate-token-rank-ccc/README.md

@@ -0,0 +1,5 @@
+# Ranking adversarial token replacements without model evaluations
+
+*Category: AI safety and alignment.*
+
+An automated red-team optimizer modifies a prompt one position at a time to move a language model toward a predefined test response. At each search step, the optimizer has already chosen the position and generated 64 candidate replacement tokens. For example, it might consider replacing `Explain` with `Describe`, `Show`, or `Reveal`. Normally, it would run the full language model on all 64 modified prompts and measure which replacement reduces the target loss most. The agent's only job is to predict that ordering without access to the model: it receives the current prompt and target, the 64 candidates, gradient values, current loss, and token embeddings, then returns one score per candidate. It does not choose the position, generate candidates, or apply the final replacement. It may combine gradient scores with embedding differences, context, learned token-specific priors, or a trained ranker. Evaluation covers 80 unseen search steps and measures how closely its ordering matches the ordering from actual model runs; higher agreement is better.

tasks/fastergcg-candidate-token-rank-ccc/instruction.md

@@ -0,0 +1,74 @@
+# Rank token substitutions by true loss reduction
+
+A prompt optimizer selects 64 possible token replacements using the gradient of its target loss. It would normally run the model once for every candidate to find which replacements help.
+
+Build a ranker that predicts the same ordering without running the model at grade time. For each optimization snapshot, your ranker receives the gradient, candidate tokens, prompt tokens, current loss, and embedding matrix. It returns one score for each candidate.
+
+## Deliverable
+
+Write `/app/output/ranker.py`. It must define:
+
+```python
+def rank(features: dict) -> numpy.ndarray:
+    ...
+```
+
+The grader imports `ranker.py` as the module `ranker` and calls `rank(features)` once per snapshot. You may add helper modules, weights, tables, or configuration files under `/app/output/`.
+
+Only `/app/output/` is copied to the grading environment. Everything your ranker needs must be inside that directory. Use regular files and directories. Do not use symbolic links, hard links, or special files.
+
+## Input
+
+`features` is a new dictionary for each snapshot with these keys:
+
+* `grad_row`: A `float32` array with shape `(32000,)`. Entry `j` is the gradient for vocabulary token `j`.
+* `candidate_ids`: An `int64` array with shape `(64,)`. The ids are distinct, sorted, and drawn from the printable ASCII token set.
+* `current_token_id`: The current token id as an integer from `0` to `31999`.
+* `current_loss`: The current positive finite target loss.
+* `prefix_ids`: A nonempty list of token ids before the position being changed.
+* `post_ids`: A nonempty list of token ids between that position and the target.
+* `target_ids`: A nonempty list of target token ids.
+* `step`: The optimizer step. It is one of `10, 20, ..., 100`.
+* `embedding_matrix`: A read only `float32` array with shape `(32000, 4096)`.
+
+## Output
+
+Return 64 finite real numbers with shape `(64,)`. A NumPy array, list, or tuple is accepted.
+
+Output position `i` must score `features["candidate_ids"][i]`. Do not return token ids, indices, or a sorted array. Lower scores mean that a candidate is predicted to reduce the loss more. Only the ordering matters. Ties are resolved by the original candidate order.
+
+For candidate `i`, the true value is:
+
+```text
+loss after replacing the current token with candidate i minus current_loss
+```
+
+A negative value means the replacement helps.
+
+## Scoring
+
+The grader compares your predicted ordering with the true loss change ordering on unseen optimization snapshots. The metric is pooled rank concordance correlation, or `pooled_rank_ccc`. Higher is better.
+
+Leaving candidates in their given order defines the zero reward baseline. Ranking candidates by their value in `grad_row` earns a small positive reward. Better rank agreement earns a higher reward, with no upper cutoff where improvements stop counting.
+
+If one call raises an exception or returns an invalid value, that snapshot uses the given candidate order. A missing entry point, invalid submitted tree, process crash, or timeout scores zero for the full run.
+
+## Runtime
+
+The full grading run imports your module and calls `rank` 80 times. It must finish within 300 seconds. The grader uses one CPU thread, 32 GiB of memory, no GPU, and no network.
+
+The model weights are not available at grade time. The embedding matrix is passed in `features`. The Vicuna tokenizer is available at `/opt/assets/vicuna-tokenizer/` if needed.
+
+## Development files
+
+You may use these files while building the ranker:
+
+* `/app/gcg_states.py` creates labeled development snapshots.
+* `/app/data/dev_behaviors.csv` contains 100 development behaviors.
+* `/app/data/token_allowlist.npy` contains the allowed printable ASCII token ids.
+* `/app/example_ranker.py` is a minimal working example.
+* `/app/work/` is scratch space.
+
+These files do not move to the grading environment. Copy anything your ranker needs into `/app/output/`.
+
+The development environment has one H100 GPU, 4 physical CPU cores, 32 GiB of memory, and no general internet access. NumPy, SciPy, scikit learn, PyTorch, and Transformers are installed.

tasks/fastergcg-candidate-token-rank-ccc/task.toml

@@ -0,0 +1,46 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/fastergcg-candidate-token-rank-ccc"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Machine Learning and AI"
+subcategory = "Interpretability and model inspection"
+task_objective = [ "Implement", "Optimize", "Analyze",]
+artifact_type = [ "Single script or program",]
+expert_time_estimate_hours = 6.0
+
+[verifier]
+network_mode = "no-network"
+timeout_sec = 7200.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 21600.0
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 10800.0
+os = "linux"
+cpus = 4
+memory_mb = 32768
+storage_mb = 307200
+gpus = 1
+gpu_types = [ "H100",]
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/grpo-rl-halfcheetah-advantage-estimator/README.md

@@ -0,0 +1,5 @@
+# Estimating action advantages for HalfCheetah policy training
+
+*Category: Model training. Subcategory: Reinforcement learning.*
+
+The agent must estimate how much each action helped a simulated HalfCheetah robot so a fixed PPO training program can learn a strong running policy. After every rollout, the agent receives observations, actions, rewards, episode endings, and the resulting next observations, then returns one advantage value per action. An advantage says whether an action performed better or worse than expected; PPO uses positive values to make an action more likely and negative values to discourage it. The agent controls only these estimates, not the policy, optimizer, or simulator, but it may retain state across rollouts. It can use discounted returns, generalized advantage estimation, a learned value baseline, recent-rollout replay, or time-dependent corrections to assign credit when rewards reflect many earlier actions. Evaluation trains 12 policies from hidden seeds and tests each for 20 episodes. The score is the mean raw episode return across all 240 evaluations; higher is better.

tasks/grpo-rl-halfcheetah-advantage-estimator/instruction.md

@@ -0,0 +1,114 @@
+# Advantage estimation for a frozen PPO-clip harness
+
+Design the advantage values used by a fixed PPO training program in Gymnasium's
+`HalfCheetah-v4` environment. Your goal is to maximize the trained policy's average episode return
+across hidden training and evaluation seeds.
+
+The only part you control is the advantage assigned to each action in each rollout. An advantage
+says whether an action produced a better or worse outcome than expected. PPO uses these values to
+update the policy.
+
+The program collects 128 steps from 8 environments at a time. It runs 4 training epochs per
+iteration. Each epoch uses 4 batches of 256 transitions. Training ends after 976 iterations, or
+999,424 environment steps.
+
+The program trains only the policy. It does not normalize, clip, or rescale the advantages that
+you return. Your array is passed directly to the training loss.
+
+## Deliverable
+
+Write `/app/output/advantage.py`, defining `class AdvantageEstimator` with two methods:
+
+```python
+class AdvantageEstimator:
+    def __init__(self, obs_dim, act_dim, num_envs, num_steps, total_iterations):
+        ...
+
+    def estimate(self, rollout) -> numpy.ndarray:
+        ...
+```
+
+The grader calls your code as follows:
+
+- `__init__` runs once per training run, before any environment interaction, with all five values
+  passed as keyword arguments: `obs_dim=17`, `act_dim=6`, `num_envs=8`, `num_steps=128`,
+  `total_iterations=976`.
+- `estimate` runs once per iteration and must return a C-contiguous `float32` array of shape
+  `(num_steps, num_envs)` that is finite everywhere.
+- The instance persists for the whole training run, so it can carry and fit its own state,
+  including its own networks and optimizers, using the arrays it is handed.
+- Only `/app/output/` carries over into the graded run, and it must be fully self-contained there.
+  `advantage.py` can import sibling modules and read data files from that directory, but nothing
+  outside `/app/output/` is available when it is graded.
+
+`rollout` is a `dict` of freshly allocated numpy arrays:
+
+| key | shape | dtype | meaning |
+|---|---|---|---|
+| `obs` | `(T, N, obs_dim)` | `float32` | the observation the policy acted on at step `t` in env `n`, after the harness's running whitening and clipping |
+| `next_obs` | `(T, N, obs_dim)` | `float32` | the observation that step produced, whitened the same way. Where an episode ended at `t` this is that episode's final observation, not the first observation of the next one |
+| `actions` | `(T, N, act_dim)` | `float32` | the action taken |
+| `logprobs` | `(T, N)` | `float32` | its log-probability under the policy that took it |
+| `rewards` | `(T, N)` | `float32` | the reward the harness optimises: the environment reward after the harness's running scaling and clipping |
+| `terminations` | `(T, N)` | `bool` | the environment reported termination at that step |
+| `truncations` | `(T, N)` | `bool` | the environment reported truncation at that step |
+| `iteration` | - | `int` | 0-based index of this iteration |
+
+## Scoring
+
+The grader trains a policy with your estimator and measures its average episode return. It uses
+the environment's raw reward before any scaling by the training program.
+
+- Twelve training runs are executed, one per hidden training seed.
+- Each trained stochastic policy is rolled out for 20 evaluation episodes of 1000 steps, on
+  environments built from hidden evaluation seeds. These seeds are not present in this container
+  and differ from any seed you use locally.
+- The metric is the arithmetic mean of all 240 episode returns.
+- Higher is better. Every improvement counts.
+- An estimator no better than a trivial one scores zero.
+
+During an iterated research run, the intermediate grader uses separate hidden training and
+evaluation seeds. It measures the same outcome with six training runs, so its score is noisier
+than the final score.
+
+## Hard constraints
+
+The submission scores zero if any of these conditions occurs:
+
+- `/app/output/advantage.py` is missing or empty, or defines no `AdvantageEstimator`
+- `__init__` or `estimate` raises, or `estimate` returns anything other than a finite,
+  C-contiguous `float32` array of shape `(128, 8)`
+- a graded training run does not finish within 1500 seconds of wall clock (it is SIGKILLed at that
+  point)
+- the estimator process imports `gymnasium`, `mujoco`, or any other simulator package, constructs
+  an environment, or spawns a child process
+- any one of the twelve graded training runs fails for any reason above
+
+The estimator runs in its own process and receives nothing but the arrays above. It cannot reach
+the policy, the optimizer, the environments, or their random state.
+
+## Environment
+
+- 8 CPU cores, 14336 MB memory, 0 GPUs, no network access.
+- Installed packages are `torch` with CPU support, `numpy`, `gymnasium`, and `mujoco`.
+- The training program uses one PyTorch thread. The estimator process uses two threads through
+  `OMP_NUM_THREADS=2` and `torch.set_num_threads(2)`.
+- A full 976 iteration run with a cheap estimator takes about four minutes on an idle machine.
+
+`/app/harness/` is read-only and is restored from a pristine copy before grading. Run it yourself
+with any seeds you like:
+
+```
+python3 /app/harness/train.py --seed 0 --submission /app/output \
+    --ckpt /app/runs/s0/policy.pt --log /app/runs/s0/log.json
+python3 /app/harness/eval_policy.py --ckpt /app/runs/s0/policy.pt --seeds 101,102,103,104,105
+```
+
+`train.py` exit codes:
+
+- `0`: completed run
+- `2`: the estimator broke its contract
+- `3`: the run hit the wall-clock cap
+- `4`: it reached outside the arrays it was given
+
+`--log` records the raw episodic returns seen during training.

tasks/grpo-rl-halfcheetah-advantage-estimator/task.toml

@@ -0,0 +1,65 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/grpo-rl-halfcheetah-advantage-estimator"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+name = "advantage-estimation-half-cheetah"
+task_slug = "grpo-rl-halfcheetah-advantage-estimator"
+expert_time_estimate_hours = 4.0
+title = "Advantage estimation for a frozen PPO-clip harness on HalfCheetah-v4 at a 1M-step budget"
+category = "Model Training and ML Infrastructure"
+subcategory = "Reinforcement learning"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program",]
+metric_name = "Mean undiscounted episodic return on HalfCheetah-v4 after a fixed 999,424-environment-step training run of the frozen PPO-clip harness, averaged over 240 held-out evaluation episodes (12 sealed training seeds x 20 sealed evaluation seeds), in raw environment reward"
+objective = "maximize"
+reward_map = "rational_squash"
+open_ended = true
+graded_deliverable = "/app/output/advantage.py"
+
+[verifier]
+timeout_sec = 15000.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+user = "agent"
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/label-efficient-risk-estimator/README.md

@@ -0,0 +1,5 @@
+# Estimating model performance without all labels
+
+*Category: Evaluation, calibration, and robustness. Subcategory: Metric estimation.*
+
+The task requires the agent to estimate the average loss of a target classifier on 2,000 test samples. It has the target classifier’s predicted probabilities for every sample but may request true labels for only up to 400 of them. The agent also has a cheaper classifier’s predictions for all 2,000 samples, which may help identify more difficult regions of the dataset. A basic approach selects examples randomly and averages their observed losses. Better approaches may select more informative examples and use the cheaper predictions to reduce noise without biasing the estimate.

tasks/label-efficient-risk-estimator/instruction.md

@@ -0,0 +1,105 @@
+# Label-efficient risk estimation
+
+A classifier `f` assigns a probability distribution over `C` classes to each of `N = 2000`
+unlabelled pool examples. Its risk on that pool is
+
+$$
+R = \frac{1}{N} \sum_i -\log \text{target\_probs}[i, y_i]
+$$
+
+where `y_i` is the true (unknown) class of example `i`. You may buy at most `M` of these
+labels, one at a time, choosing each next example after seeing every label you've already
+bought. Your job is to estimate `R`.
+
+You're also given, for the same pool and row order, the predictive distributions of a second,
+cheaper classifier over the same `C` classes. You aren't told how good it is, and that varies
+from pool to pool.
+
+## Deliverable
+
+Write `/app/output/estimator.py`, defining a class named exactly `Estimator`:
+
+```python
+class Estimator:
+    def __init__(self, pool: dict, budget: int, rng: numpy.random.Generator) -> None: ...
+    def next_index(self) -> int: ...
+    def observe(self, index: int, label: int) -> None: ...
+    def estimate(self) -> float: ...
+```
+
+`pool` has exactly these keys:
+
+| key | type |
+| --- | --- |
+| `target_probs` | C-contiguous `float64` ndarray, shape `(n_pool, n_classes)`, rows sum to 1 |
+| `surrogate_probs` | C-contiguous `float64` ndarray, shape `(n_pool, n_classes)`, rows sum to 1 |
+| `n_pool` | `int`, always 2000 |
+| `n_classes` | `int`, always 2 |
+
+Requirements:
+- Helper modules can live anywhere under `/app/output/`, as long as they're importable from
+  `estimator.py`.
+- Allowed packages: `numpy`, `scipy`. Nothing else is installed, and there's no network access.
+- Grading runs in a separate environment from this one. Only the contents of `/app/output`
+  cross over, so your solution must be fully self-contained there.
+
+The harness, not your code, drives the loop: it calls `next_index()` exactly `budget` times,
+and right after each call it calls `observe(index, label)` with the true class of the row you
+named. Naming a row you've already bought is legal and still uses up one unit of budget. After
+the last `observe`, `estimate()` is called once.
+
+## How it's scored
+
+- One *cell* is one held-out pool paired with one label budget `M`, where `M` is one of
+  `{50, 100, 200, 400}`.
+- Every cell is replayed over 4000 pinned seeds.
+- For each seed, the harness builds a fresh `Estimator` and records the squared error
+
+$$
+(\text{estimate}() - R)^2
+$$
+
+  against the exact pool risk `R`, which it knows and you don't.
+- A cell's score is
+
+$$
+\text{score} = \frac{\text{median over the 4000 seeds of your squared error}}{\text{median over the SAME 4000 seeds of the squared error of the reference}}
+$$
+
+- The reference draws its `M` rows uniformly at random, without replacement, from the same
+  `rng` seed you're given, and returns the plain mean of their `-log target_probs[i, y_i]`.
+- The graded metric is the **median of the cell scores** across every held-out cell.
+- **Lower is better.** Matching the reference scores zero; every value strictly below the
+  reference scores strictly higher, with no cutoff where further reduction stops counting. Push
+  it as low as you can.
+
+The held-out pools span several source corpora, classifier pairs, and calibration regimes,
+including pools where the target classifier is accurate and well-calibrated and pools where
+it's badly miscalibrated. No single fixed design wins on all of them.
+
+## Development data
+
+`/app/data/dev/` holds twelve labelled pools you can use however you like. Each
+`/app/data/dev/<pool_id>/` contains:
+
+- `target_probs.npy` - `float64` `(2000, n_classes)`
+- `surrogate_probs.npy` - `float64` `(2000, n_classes)`
+- `labels.npy` - `int64` `(2000,)`, values in `[0, n_classes)`
+- `meta.json` - `{"pool_id", "n_pool", "n_classes"}`
+
+The held-out pools come from disjoint shards of the same corpora and are never shipped to you.
+
+## Execution contract
+
+- Your module runs as an unprivileged user with **no writable directory**, including
+  `/app/output`. It's re-executed from source for **every seed**, so no state survives from one
+  seed to the next: do per-pool precomputation in `__init__`, not at module scope. The pool row
+  order is re-randomised on every seed, so row indices mean nothing across seeds.
+- `/app/output` must hold at most 2000 files totalling at most 256 MB.
+- Wall clock limits: **5 seconds per seed**, and **900 seconds for a whole cell** (all 4000
+  seeds of one pool-budget pair). A cell runs with one CPU core available to it.
+- Any of the following makes that seed score the worst-case squared error: an exception, a
+  `next_index()` outside `[0, n_pool)`, a non-finite `estimate()`, or exceeding the per-seed
+  clock. Exceeding the per-cell clock, or trying to obtain more than `budget` labels in a seed,
+  scores the worst case for the whole cell.
+- A missing, empty, or unimportable `/app/output/estimator.py` scores zero.

tasks/label-efficient-risk-estimator/task.toml

@@ -0,0 +1,56 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/label-efficient-risk-estimator"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Machine Learning and AI"
+subcategory = "Evaluation, Calibration, and Robustness"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program",]
+expert_time_estimate_hours = 4.0
+
+[verifier]
+timeout_sec = 2700.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/reppo-reliable-onpolicy-control-trainer/README.md

@@ -0,0 +1,5 @@
+# Training reliable control policies under tight budgets
+
+*Category: Model training. Subcategory: Reinforcement learning.*
+
+The agent must train a controller from scratch for each of six unseen physical-control tasks, such as balancing a pendulum or moving a robotic arm, using at most 400,000 environment interactions and 45 CPU-seconds. Every task presents eight observation values and accepts two continuous actions, but hidden rotations and permutations prevent the trainer from relying on fixed meanings for those coordinates. The agent controls the entire training procedure and periodically reports the deterministic policy that the evaluator should test. It may use stable on-policy reinforcement learning, improved value estimates, system identification followed by an analytic controller, or safeguards that preserve the best policy found so far. Success requires more than briefly reaching a high return: the policy must achieve at least 90% of a task-specific reference level at each of the final ten checkpoints. Evaluation covers 72 independent runs across six environments and twelve hidden seeds. The score is the fraction of runs meeting this reliability condition; higher is better.

tasks/reppo-reliable-onpolicy-control-trainer/instruction.md

@@ -0,0 +1,146 @@
+# Train control policies that hit a performance bar on every seed and hold it
+
+Write a reinforcement-learning training procedure at `/app/solution/trainer.py`. The score is
+the **reliable-success fraction**. It is the fraction of runs whose policy reaches 90% of a
+reference level and stays there for the last ten evaluation checkpoints.
+
+The grader runs your procedure from scratch 72 times. It uses six unseen continuous-control
+environments with twelve sealed random seeds each. Each run gets 400,000 environment
+interactions and 45 CPU-seconds. Nothing carries over between runs. Push the reliable-success
+fraction as high as you can. Higher is always better. A procedure that does no learning scores 0.
+
+## The deliverable
+
+`/app/solution/trainer.py` must define, at module level:
+
+```python
+def train(env, seed, budget, report) -> None
+```
+
+`env` is a vectorised environment handle owned by the harness:
+
+| member | meaning |
+| --- | --- |
+| `env.reset()` | `np.ndarray (env.n_envs, env.obs_dim)` float32 |
+| `env.step(actions)` | `(obs, reward, done)`; `actions` must be `(env.n_envs, env.act_dim)` and coerce to float32 with every entry in `[-1, 1]` |
+| `env.n_envs` | 64 |
+| `env.obs_dim` | 8 |
+| `env.act_dim` | 2 |
+| `env.max_episode_steps` | 100 |
+
+Episodes have a fixed length: `done` is true only on an episode's final step, and the batch
+auto-resets on the next `step`. Once the interaction budget is spent, `env.step` raises
+`RuntimeError`.
+
+`seed` is the run's integer seed. `budget` carries `budget.total_env_steps` (400000),
+`budget.cpu_seconds` (45.0), and `budget.n_checkpoints` (40).
+
+`report(policy_fn)` hands the harness the deterministic policy it should evaluate from then
+on. `policy_fn` maps `np.ndarray (B, 8)` float32 to `(B, 2)` with every entry in `[-1, 1]`,
+and must have no side effects, since the harness calls it on evaluation states that never
+touch your training environment. Call `report` as often as you like; only the most recently
+reported policy is evaluated.
+
+Actions from `policy_fn` and from `env.step` are read as float32: any array whose values
+convert exactly to float32 and whose size is `B * 2` is accepted, regardless of dtype or
+memory order. Values are then clipped into `[-1, 1]` with a float32 tolerance of `1e-4`, so
+rounding at the boundary costs nothing; going further outside ends the run.
+
+You may add helper modules under `/app/solution/`. That directory is everything that reaches
+the grader, so anything your trainer imports or loads must live inside it, subject to:
+
+- no symbolic or hard links
+- at most 2000 files
+- at most 64 MB total
+
+## How a run is scored
+
+The harness evaluates at 40 checkpoints, one every 10,000 environment steps. At checkpoint
+`k` it runs the most recently reported `policy_fn` on that environment's 32 fixed evaluation
+initial states, one full 100-step episode each, and records the mean undiscounted return
+`R_k`. This evaluation does not consume your interaction budget.
+
+`R_k` is normalised against two per-environment constants:
+
+$$s_k = \mathrm{clip}\left(\frac{R_k - R_{\text{rand}}}{R_{\text{ref}} - R_{\text{rand}}}, 0, 1\right)$$
+
+`R_rand` is the return of uniform-random actions and `R_ref` is a fixed reference level. The
+constants for the graded environments are not disclosed.
+
+A run is **reliably performant** when $s_k \geq 0.9$ at all of the last ten checkpoints, i.e.
+over the final 100,000 environment steps of the run. The metric is the fraction of the 72
+runs that are reliably performant.
+
+A checkpoint reached before your first `report` call scores $s_k = 0$, and so does every
+checkpoint after a run has been ended by the harness. If `train` returns early, the remaining
+checkpoints are evaluated with the policy you reported last.
+
+Each run gets a private, empty working directory as its current directory and as `TMPDIR` and
+`HOME`. Nothing written there survives the run. `/app/solution` is read-only while your
+trainer executes, and no other path is writable, so the 72 runs are independent and cannot
+pass state to one another. POSIX shared memory (`/dev/shm`) is also not writable inside a
+graded run, so `multiprocessing` primitives that need it are unavailable. Threads and
+`subprocess` work. The CPU meter sums every process your run creates. Each run executes under
+its own uid, and System V IPC, POSIX message queues, socket binding, ptrace and kernel keyrings
+are refused with `EPERM` inside a graded run.
+
+## What ends a run
+
+Each of the following stops the run at that point, so every checkpoint from then on scores
+$s_k = 0$:
+
+- spending more than 45 CPU-seconds. The meter covers every process your run creates, including
+  helper processes and the work your `policy_fn` does answering evaluation queries, and it
+  starts when `train` is entered; interpreter and library import time is not charged.
+- taking more than 150 seconds of wall-clock time.
+- returning an action array of the wrong size, containing a non-finite value, or with an
+  entry outside `[-1, 1]`.
+- raising an exception out of `train` or out of `policy_fn`.
+
+A deliverable that is missing, empty, unparseable, or that does not define a module-level
+`train` taking four positional arguments scores 0 outright.
+
+## The environments
+
+`/app/envs.py` holds all six families, with their disclosed parameter ranges and dynamics:
+
+- a 2-D double integrator
+- an inverted-pendulum balance task
+- a pendulum swing-up
+- a cart-pole swing-up
+- a planar two-link reacher
+- a pendulum swing-up with a one- or two-step actuation delay
+
+Every family is presented through the same 8-dimensional observation and 2-dimensional action
+interface: families that drive one actuator ignore the second action component, and families
+with fewer than eight state features occupy a subspace of the observation.
+
+Each environment also carries two transforms drawn with its own parameter seed: a fixed
+orthogonal rotation applied to the observation vector, and a fixed signed permutation applied
+to the action vector before the dynamics see it. The graded environments use parameter draws,
+transforms, evaluation states, and seeds that you do not have.
+
+## Iterating locally
+
+`/app/public_panel.json` holds six public environments, one draw from each family, with their
+own `R_rand` and `R_ref` constants and three public seeds. These are not the graded ones.
+
+```
+python3 /app/run_public.py
+python3 /app/run_public.py --envs env2 --seeds 0 --workers 4
+```
+
+It prints, per run, the mean evaluation return at each of the 40 checkpoints together with
+that environment's `R_rand` and `R_ref`, so you can apply the normalisation above yourself.
+
+`/app/panel.py` and `/app/child_main.py` are the same harness the grader runs, including the
+meters and the evaluation protocol. `/app/envs.py`, `/app/panel.py`, `/app/child_main.py`,
+`/app/run_public.py`, and `/app/public_panel.json` are inputs; only `/app/solution/` is yours
+to change.
+
+## The machine
+
+- 8 CPU cores, 14 GB of RAM, no GPU, no network
+- packages installed: `numpy`, and a CPU build of `torch`
+- one thread per process (`OMP_NUM_THREADS=1`); extra threads will not buy you compute
+- the 72 graded runs are executed 8 at a time

tasks/reppo-reliable-onpolicy-control-trainer/task.toml

@@ -0,0 +1,60 @@
+schema_version = "1.4"
+artifacts = [ "/app/solution",]
+
+[task]
+name = "bespokelabs/reppo-reliable-onpolicy-control-trainer"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+task_slug = "reppo-reliable-onpolicy-control-trainer"
+category = "Model Training and ML Infrastructure"
+subcategory = "Model Training and Alignment"
+metric_name = "reliable_success_fraction"
+objective = "maximize"
+graded_deliverable = "/app/solution/trainer.py"
+device = "cpu"
+expert_time_estimate_hours = 12.0
+
+[verifier]
+timeout_sec = 2400.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+user = "agent"
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/sae-sparse-dict-nmse-frontier/README.md

@@ -0,0 +1,5 @@
+# Sparse Coding of Language Model Activations
+
+*Category: Interpretability.*
+
+The task is to reconstruct activation vectors from the eighth block of GPT-2 small while representing each vector with only a small number of learned components. An activation vector is an internal 768-number representation produced when the language model processes text. The agent submits up to 8,192 fixed 768-dimensional dictionary vectors and an encoder that selects and weights a few of them for each activation. The grader reconstructs an activation by adding the selected dictionary vectors, each multiplied by its assigned weight. The encoder may use a different set of vectors for every activation, but the average number of selected vectors across all evaluated activations may not exceed 32. Solutions may train a sparse autoencoder, improve which dictionary vectors the encoder selects, refit the selected weights with least squares, and replace dictionary vectors that are rarely used. The final objective is to minimize normalized mean squared reconstruction error on 1,048,576 held-out activations. Lower error is better.

tasks/sae-sparse-dict-nmse-frontier/instruction.md

@@ -0,0 +1,89 @@
+# Sparse coding of GPT-2 activations
+
+Build a sparse dictionary that reconstructs GPT-2 small layer 8 residual stream activations.
+
+## Goal
+
+The grader measures normalized reconstruction error on 1,048,576 hidden activations:
+
+$$
+\frac{\sum_i \lVert x_i-\hat{x}_i\rVert^2}
+{\sum_i \lVert x_i-\bar{x}\rVert^2}.
+$$
+
+Lower is better. The numerator and denominator are pooled across the full hidden set before division.
+
+Reconstructing every activation with one fixed vector earns zero reward. A method no better than the best 32 dimensional linear code earns very little.
+
+The average number of active dictionary entries may not exceed 32 per activation. The dictionary may contain at most 8,192 entries.
+
+## Deliverable
+
+Create these two files:
+
+- `/app/output/dictionary.pt`
+- `/app/output/encoder.py`
+
+Only files under `/app/output` are submitted.
+
+### Dictionary
+
+Save `dictionary.pt` with `torch.save`. It must be a plain dictionary of tensors with:
+
+- `W_dec`: a finite `float32` CPU tensor with shape `[768, n]`, where `1 <= n <= 8192`.
+- `b_pre`: a finite `float32` CPU tensor with shape `[768]`.
+
+Column `j` of `W_dec` is dictionary entry `j`. The grader reconstructs each activation as:
+
+$$
+\hat{x}=b_{\mathrm{pre}}+\sum_j \mathrm{val}_j W_{\mathrm{dec}}[:,\mathrm{idx}_j].
+$$
+
+### Encoder
+
+`encoder.py` must define:
+
+```python
+def load(device: str) -> object:
+    ...
+```
+
+The returned object must define:
+
+```python
+def encode(x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    ...
+```
+
+The grader calls `load("cuda")` once. Each `encode` call receives a `float32` tensor with shape `[8192, 768]` on the GPU.
+
+Return `(idx, val)`:
+
+- `idx` has shape `[8192, K]`, integer dtype, and values from `0` to `n - 1`.
+- `val` has the same shape, floating point dtype, and finite values.
+- `K` may be between 0 and 8,192 and may change between calls.
+- Entries with value exactly zero are inactive and do not count toward the sparsity budget.
+- A row may not name the same dictionary entry twice.
+
+## Data
+
+`/app/extract_acts.py` shows how activations are created. It splits documents into non-overlapping 64 token windows, runs GPT-2 small in float32, reads the residual stream after block 8, centers each token across its 768 channels, and normalizes it to unit length.
+
+Development data is available at:
+
+- `/app/data/openwebtext/plain_text/train-00000-of-00080.parquet`
+- `/app/data/openwebtext/plain_text/train-00001-of-00080.parquet`
+
+The hidden activations use a different OpenWebText shard and the same extraction code.
+
+## Grading and limits
+
+The grader calls `encode` 128 times, in fixed order, for 1,048,576 activations total. It reconstructs in float32 and accumulates the error sums in float64.
+
+Importing `encoder.py`, loading the encoder, and all encoding calls share a 900 second limit. The whole grading run has a 1,500 second limit.
+
+`/app/output` may contain at most 20,000 files and directories. It may not contain symbolic links, hard links, or special files. Load bundled files relative to `encoder.py`, since the grader copies the output directory before running it.
+
+The grading machine has one NVIDIA H100 80 GB GPU, 4 physical CPU cores, 32 GiB RAM, and about 300 GB disk. The process has no internet access and runs with one CPU thread. PyTorch, Transformers, NumPy, SciPy, and PyArrow are installed. The pinned GPT-2 checkpoint is available at `/opt/assets/gpt2`.
+
+Any malformed output, exception, timeout, non-finite value, file contract violation, or resource limit violation receives zero reward.

tasks/sae-sparse-dict-nmse-frontier/task.toml

@@ -0,0 +1,46 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/sae-sparse-dict-nmse-frontier"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Machine Learning and AI"
+subcategory = "Unsupervised and representation learning"
+task_objective = [ "Optimize", "Implement",]
+artifact_type = [ "Single script or program", "Generated output artifact",]
+expert_time_estimate_hours = 6.0
+
+[verifier]
+network_mode = "no-network"
+timeout_sec = 7200.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 21600.0
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 10800.0
+os = "linux"
+cpus = 4
+memory_mb = 32768
+storage_mb = 307200
+gpus = 1
+gpu_types = [ "H100",]
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/shortest-valid-ci-l2-ece/README.md

@@ -0,0 +1,5 @@
+# Tight confidence intervals for prediction uncertainty estimation
+
+*Category: Evaluation, calibration, and robustness. Subcategory: Metric estimation.*
+
+The task provides labels and class probabilities from classifiers with 2 to 50 classes, and samples of 200 to 10,000 rows. The agent is tasked with returning a short confidence interval for _squared calibration error_ among the one to three most likely classes. This interval is a range for how closely the stated chances match the observed results, and the interval itself must include the _true_ error in at least some fraction of repeated samples. Sampling noise changes with the class count and the shape of the probabilities, so a narrow interval can miss the true error in some settings. One may start with a standard range based on the sample size and the observed error. Further gains may come from better estimates of sampling noise and ranges that use the most likely probabilities.

tasks/shortest-valid-ci-l2-ece/instruction.md

@@ -0,0 +1,110 @@
+# Shortest valid confidence interval for the squared l2 calibration error
+
+Given predicted class probabilities and their true labels, return a confidence interval for the
+squared calibration error defined below. The interval should be as short as possible while still
+covering the true value in at least 88% of repeated samples.
+
+## Submission
+
+- File: `/app/output/interval.py`, plus any helper module it imports. Nothing outside
+  `/app/output` reaches the grader.
+- It must expose:
+
+```python
+def ece2_interval(Z, Y, k, alpha, rng) -> tuple[float, float]:
+    ...
+```
+
+- The function must return a `1 - alpha` confidence interval for the squared top-1-to-k l2
+  expected calibration error of the predictions in `Z`.
+- Return `(lo, hi)`: two finite floats with `0.0 <= lo <= hi <= k`.
+
+## The estimand
+
+For a K-class predictor, let `Z` hold predicted probability vectors and let `r_1, ..., r_k` be
+the classes with the k largest entries of a row, so `Z_(1:k)` are those entries in
+non-increasing order and `Y_{r_(1:k)}` the matching label indicators. With the expectation over
+the joint law of the row and its label,
+
+$$
+\mathrm{ECE}^2_{1:k} = \mathbb{E} \left\| \mathbb{E}\left[ Y_{r_{(1:k)}} - Z_{(1:k)} \,\middle|\, Z_{(1:k)} \right] \right\|_2^2
+$$
+
+This is zero exactly when the top-k predicted probabilities are calibrated, and it lies in
+`[0, k]`.
+
+## Arguments and return
+
+| name | contract |
+|---|---|
+| `Z` | C-contiguous `float64` array, shape `(n, K)`, rows are probability vectors summing to 1 |
+| `Y` | `int64` array, shape `(n,)`, realised class indices in `[0, K)` |
+| `k` | `int` in `{1, 2, 3}`, always `k < K` |
+| `alpha` | `0.10` |
+| `rng` | a freshly seeded `numpy.random.Generator`, one per call |
+
+- A call counts as a non-covering interval of length `k` if it raises, returns an invalid value,
+  or runs for more than 2.0 seconds.
+- `rng` is the only random number generator supplied by the grader. The grader draws the same
+  data each time. Seed any other source of randomness so repeated grading gives the same result.
+
+## How it is scored
+
+- Your routine runs against a sealed panel of data-generating settings that is not in this
+  container.
+- Each setting is graded over `R = 2000` seeded replications. Each replication is an independent
+  draw of `(Z, Y)` with its own true `ECE^2_{1:k}`. The grader calls your routine once for each
+  replication in a fresh process.
+- For setting `s` with `k = k_s`:
+  - `coverage_s` = fraction of the 2000 replications whose interval contains that
+    replication's true `ECE^2_{1:k}`
+  - `relative_length_s = mean(hi - lo) / k_s`
+  - score:
+
+$$
+\text{score}_s =
+\begin{cases}
+\text{relative\_length}_s & \text{if } \text{coverage}_s \ge 0.88 \\
+1.0 & \text{otherwise}
+\end{cases}
+$$
+
+- The grader reports the unweighted mean of `score_s` over all settings as `metric`.
+
+Lower is better. The interval `(0.0, k)` always covers the true value, but it gives a metric of
+`1.0` and earns zero credit. Every metric below `1.0` earns more credit as it decreases.
+
+## The sealed panel
+
+Settings are drawn from the generator in `/app/panel.py`. Across the panel:
+
+* `K` is in `{2, 3, 5, 10, 50}`, `k` in `{1, 2, 3}` with `k < K`, `n` in `{200, 500, 2000, 10000}`.
+* The distribution of `Z` mixes a uniform distribution on the simplex with a Dirichlet or
+  logit-normal distribution. The density of `Z_(1:k)` is bounded away from zero on
+  `{z_1 >= ... >= z_k >= 0, k/K <= sum z <= 1}`.
+* The calibration curve is a smooth per-rank over- or under-statement of the predicted
+  probability, and labels depend on a row only through its top-k entries.
+* Each setting carries a fixed 41-point grid of true squared calibration errors, and every
+  replication draws one of them, so the true value **varies between replications of the same
+  setting**. Some settings include exactly calibrated replications; others reach a squared
+  error of order 0.1.
+
+## Data notes
+
+* `/app/panel.py` is the generator the grader uses. `draw_replication(spec, theta, rng)`
+  returns `(Z, Y)` for a setting `spec` whose true `ECE^2_{1:k}` is exactly `theta`.
+  `theta_for(spec, rng)` picks a replication's `theta` from the setting's grid.
+  `estimate_a(spec, n_draws, seed)` and `sigma0_sq(K, k)` are the same Monte-Carlo helpers used
+  to build the panel.
+* `/app/data/dev_panel.json` holds 24 development settings, drawn three independent times from
+  that same generator, each with its `A`, its `theta_grid`, and the rest of its parameters. Use
+  it to generate replications with known true values and measure coverage and length yourself.
+  The three draws differ, so a choice tuned to one need not work for another.
+
+## Packages and environment
+
+* `python3` with `numpy` and `scipy` is available.
+* There is no network.
+* Each grade-time process serves at most one replication per setting and is destroyed
+  afterward, with no writable location surviving it, so nothing carries over from one call to
+  the next.

tasks/shortest-valid-ci-l2-ece/task.toml

@@ -0,0 +1,56 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/shortest-valid-ci-l2-ece"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Machine Learning and AI"
+subcategory = "Model evaluation and benchmarking"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program",]
+expert_time_estimate_hours = 6.0
+
+[verifier]
+timeout_sec = 1800.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 21600.0
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/svdquant-w4a4-psnr/instruction.md

@@ -0,0 +1,45 @@
+# Improve W4A4 PixArt Sigma image quality
+
+Improve the image quality of a W4A4 quantized PixArt Sigma model. Write your solution to `/app/output/quantize.py`. This must be the only file you create or modify.
+
+The file must define `quantize_model(pipe, rank=32) -> None`. The grader passes in a fresh FP16 `diffusers.PixArtSigmaPipeline` loaded from `/opt/pixart-sigma`. `rank` must be an integer from `0` to `32`. You may use the calibration prompts in `/app/data/calibration_prompts.jsonl`.
+
+## Required module format
+
+Replace every `torch.nn.Linear` in `pipe.transformer` in place. Register these tensors in the order shown. Do not register any other tensor parameters or buffers.
+
+* `qweight`: `torch.int8` with shape `(out_features, in_features)`. Values must be from `-7` to `7`.
+* `scales`: `torch.float16` with shape `(out_features, ceil(in_features / 64))`. Values must be finite and positive.
+* `l1`: `torch.float16` with shape `(in_features, r)`. Values must be finite.
+* `l2`: `torch.float16` with shape `(r, out_features)`. Values must be finite. `r` must be from `0` to `rank`, and `rank` must be from `0` to `32`.
+* `smooth`: `torch.float16` with shape `(in_features,)`. Values must be finite and positive.
+* `bias`: Include this exactly when the original layer has a bias. It must be finite `torch.float16` with shape `(out_features,)`.
+
+Do not keep the original weight. `quantize_model` must return `None`.
+
+## Required computation
+
+Use symmetric groupwise INT4 quantization over groups of 64 input channels. A shorter final group is allowed. Each layer must compute:
+
+```text
+x_s = x / smooth
+output = Q4(x_s) @ dequantize(qweight, scales).T
+       + (x_s @ l1) @ l2
+       + bias
+```
+
+Quantize each input row and group using `max(abs(group)) / 7`. Round with PyTorch's default round to even rule, clip values to `-7` to `7`, and use a scale of `1` for an all zero group. Multiply each stored code by its group scale when dequantizing the residual weight.
+
+Run the computation in FP16. You may calculate scales in FP32.
+
+## Scoring
+
+The grader compares images from your quantized model with images from the original FP16 model on unseen prompts. The score is mean PSNR in dB. Higher is better.
+
+A basic round to nearest W4A4 model defines the zero reward baseline. Scores above that baseline receive higher rewards. Invalid or nonrunning submissions receive zero.
+
+## Runtime
+
+Importing your file, loading the model, running `quantize_model`, checking the replacement modules, and saving their tensor state must finish within 900 seconds.
+
+The environment has one H100 GPU, 4 physical CPU cores, 32,768 MiB of memory, and no internet access. The grader runs separately and receives only `/app/output/quantize.py`, so the solution must be self contained.

tasks/ties-merging-clip-vitl14-eight-task-merge/README.md

@@ -0,0 +1,5 @@
+# Merging Several CLIP ViTs for Zero-Shot Classification
+
+*Category: Model training. Subcategory: Model merging and distillation.*
+
+We have a pretrained CLIP ViT L 14 vision encoder and eight copies fine tuned on different image classification datasets. The objective is to merge their weights into one frozen encoder. The resulting encoder is evaluated as a zero-shot classifier over the original datasets; the final score is the unweighted average of accuracy on all eight datasets. One may start by averaging the eight fine tuned model weights. Because the datasets are provided, it is also possible to fine tune the aggregate model on individual datasets.

tasks/ties-merging-clip-vitl14-eight-task-merge/instruction.md

@@ -0,0 +1,83 @@
+# Merge eight vision models into one encoder
+
+Create one CLIP ViT-L/14 vision encoder that performs well across eight image classification datasets.
+
+## Goal
+
+You receive one pretrained vision encoder and eight copies fine-tuned on:
+
+`sun397`, `cars`, `resisc45`, `eurosat`, `svhn`, `gtsrb`, `mnist`, and `dtd`.
+
+Return one state dictionary for the same architecture. The result is used as a single frozen encoder on all eight datasets. It may not route by dataset or keep separate model branches.
+
+The metric is mean top-1 accuracy across the eight hidden evaluation sets. Each dataset has equal weight. Higher is better.
+
+A mean accuracy of 65.23 percent or lower receives zero reward. This is the pretrained model baseline. Above that floor, reward increases with accuracy.
+
+## Assets
+
+Model weights are stored as safetensors:
+
+- Pretrained model: `/opt/assets/pretrained/model.safetensors`
+- Fine-tuned models: `/opt/assets/{task}/model.safetensors`
+
+All models have the same 391 keys and tensor shapes.
+
+## Deliverable
+
+Write `/app/output/merge.py`. It must define:
+
+```python
+def merge(
+    pretrained: dict[str, torch.Tensor],
+    experts: dict[str, dict[str, torch.Tensor]],
+    unlabeled_dir: str,
+    device: str,
+) -> dict[str, torch.Tensor]:
+    ...
+```
+
+The grader calls `merge` once with positional arguments.
+
+- `pretrained` is the pretrained state dictionary. Its values are float32 CPU tensors.
+- `experts` maps each of the eight task names to its fine-tuned state dictionary.
+- `unlabeled_dir` contains `unlabeled_dir/{task}/images.npy`. Each file is a `uint8` array with shape `[N, 3, 224, 224]`.
+- `device` is `"cuda"`.
+
+Return a dictionary with exactly the same keys and shapes as `pretrained`. Every value must be convertible to a finite float32 tensor. Float32 CPU tensors are the safest form.
+
+Only files under `/app/output` are submitted. You may include helper modules or data there. Do not use symbolic links, hard links, special files, or more than 20,000 files. Load bundled files relative to `merge.py` because the grader copies the output directory before running it.
+
+## Evaluation
+
+For each dataset, the grader loads your returned weights into `CLIPVisionModel`. It applies the frozen CLIP visual projection and the dataset's frozen zero-shot classification head. It then computes top-1 accuracy on hidden labeled images.
+
+The heads and projection are available at `/opt/assets/heads.pt`. Hidden labels are not available to your code. The images passed through `unlabeled_dir` are the same images used for scoring, but they have no labels and their order has no meaning.
+
+`merge` must return within 1,200 seconds. The full scoring process has a 1,800 second limit. A missing file, import error, exception, timeout, wrong key or shape, non-finite value, or invalid submitted tree receives zero reward.
+
+## Development data
+
+Use:
+
+- `/app/data/dev/{task}/images.npy`
+- `/app/data/dev/{task}/labels.npy`
+- `/app/data/dev/{task}/classes.json`
+- `/app/data/dev_unlabeled/{task}/images.npy`
+- `/app/eval_dev.py`
+
+Run:
+
+```bash
+/usr/bin/python3 /app/eval_dev.py
+```
+
+The development and hidden rows are separate halves of the same test splits. Pixel-exact duplicates were removed from the hidden half.
+
+## Environment
+
+The grading machine has one NVIDIA H100 80 GB GPU, 8 physical CPU cores, 64 GiB RAM, a 300 GB disk, and no internet access. PyTorch, Transformers, Datasets, Safetensors, NumPy, and Pillow are installed.
+
+The input state dictionaries use about 11 GB of host memory before `merge` starts. The output tree is read-only during grading. Write temporary files to the process working directory.
+
+CPU library threads default to one. Random seeds and deterministic settings are fixed. TF32 is disabled. The hidden evaluation uses the same settings on every run.

tasks/ties-merging-clip-vitl14-eight-task-merge/task.toml

@@ -0,0 +1,45 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/ties-merging-clip-vitl14-eight-task-merge"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Machine Learning and AI"
+subcategory = "Computer vision"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program", "Generated output artifact",]
+expert_time_estimate_hours = 6.0
+
+[verifier]
+timeout_sec = 7200.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 21600.0
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "deb.debian.org", "security.debian.org", "archive.ubuntu.com", "security.ubuntu.com", "developer.download.nvidia.com", "packages.cloud.google.com", "raw.githubusercontent.com", "nodejs.org", "registry.npmjs.org", "downloads.claude.ai", "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 14400.0
+os = "linux"
+cpus = 8
+memory_mb = 65536
+storage_mb = 307200
+gpus = 1
+gpu_types = [ "H100",]
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]

tasks/vas-maskless-deployment-feasibility/README.md

@@ -0,0 +1,5 @@
+# Guiding a frozen MDP policy with a validity mask
+
+*Category: Model training. Subcategory: Predictive modeling.*
+
+We want to play MiniDungeon - a game featuring a player interacting with a small deterministic grid-world. MiniDungeon consists of a 14×14 tile grid stacked to have 5 floors, with 24 discrete possible actions (move, mine, craft, drink, descend, rest, …) and 27 weighted achievements that determine the reward for an episode. The policy sees only a 514-value observation vector consisting of a 5×5 tile window centered on the current position of a player, plus 14 inventory and status counters. At each state of the game, some subset of the 24 actions are valid, but the player is not told which actions are valid outright. The task provides 1.1 million recorded steps from a frozen policy. The objective is to predict the validity of the actions given an observation in such a way that masking the frozen policy accordingly results in maximum reward. One may start by training a separate validity predictor for each action. Further gains may come from sharing spatial patterns across actions and changing decision thresholds for unfamiliar states.

tasks/vas-maskless-deployment-feasibility/instruction.md

@@ -0,0 +1,106 @@
+# Supply the validity mask a mask-trained policy acts under
+
+MiniDungeon is a procedurally generated dungeon crawler with 24 discrete actions. Before each
+choice, the policy needs a Boolean mask that marks which actions the environment will accept.
+During training, the policy received the true mask and ignored invalid actions by setting their
+logits to `-inf`. That mask is not available at deployment. Build a predictor to replace it.
+
+## Submission requirements
+
+Ship `/app/output/predictor.py` defining `class MaskPredictor` with exactly these three
+entry points:
+
+```python
+class MaskPredictor:
+    def __init__(self, artifacts_dir: str): ...
+    def reset(self, first_obs: np.ndarray) -> None: ...
+    def predict(self, obs: np.ndarray) -> np.ndarray: ...
+```
+
+- `predict` must return a `numpy` array of `dtype=bool` and shape `(24,)`. `True` leaves that
+  action available to the policy; `False` forces its logit to `-inf`.
+- `obs` is a C-contiguous `float32` array of shape `(514,)`, the same vector the frozen policy
+  consumes, and the only input you get.
+- `artifacts_dir` is the directory `predictor.py` was loaded from, so anything you save next to
+  it is available to `__init__`.
+- Only `/app/output/` is writable, and only what is under it carries over to the evaluation run:
+  `predictor.py` plus every weight, table, or config it loads.
+- Your deliverable directory is placed first on `sys.path`, so it may ship helper modules, but it
+  must not depend on anything you leave elsewhere.
+- There is no network.
+
+## Scoring
+
+The reference policy is deployed on a sealed set of held-out MiniDungeon maps you have never
+seen, one episode per map, 500 steps each. Each episode calls `reset` with the episode's first
+observation, then `predict` once per step; the first `predict` call of an episode receives that
+same first observation. At every step your mask is applied to the policy's logits, an action is
+sampled from the resulting distribution with a pinned RNG stream, and the environment is stepped.
+Rewards are per-step achievement rewards, tiered 1 / 3 / 5 / 8, with a theoretical maximum of 98
+in one episode.
+
+- Metric: mean episode return over the sealed episodes.
+- Direction: maximize. Higher is strictly better, with no cutoff at which further improvement
+  stops mattering.
+- Baseline: a trivial predictor (a constant mask, or one that ignores the observation) earns 0.
+  Anything worse also earns 0.
+- Determinism: the maps, the environment, and the action-sampling stream are all pinned, and
+  `OMP_NUM_THREADS=1`, so a fixed submission gets the same score every time.
+
+## What you are given
+
+Every path listed here is read-only, and all of them are present at grade time with
+byte-identical content at the same paths.
+
+- `/app/policy_weights.npz` and `/app/reference_policy.py`: the frozen policy.
+  `ReferencePolicy` loads the weights and exposes `logits(obs) -> (24,) float32`,
+  `logits_batch(obs) -> (N, 24)`, and `masked_probs(obs, mask) -> (24,) float32`. This is the same
+  code and the same weights the evaluation harness uses to produce the logits your mask is
+  applied to.
+- `/app/mdobs.py`: the observation encoder, and the authoritative description of the 514-d
+  layout: 500 dims of a 5x5 tile view centered on the player (per tile, 16 one-hot block channels
+  then 4 mob/item flag bits, tile-major, row-major), followed by 14 inventory and status dims.
+  Its `build_obs_batch(crop_block, crop_flags, extras_raw)` is the function that produced every
+  observation you will ever be given.
+- `/app/data/train_traj.npz` and `/app/data/val_traj.npz`: trajectory banks recorded by rolling
+  the frozen policy out on visible maps, 964843 and 121752 steps respectively, disjoint from
+  each other and from the evaluation maps. Both hold:
+
+  | key | dtype, shape | meaning |
+  | --- | --- | --- |
+  | `crop_block` | uint8 `(N, 25)` | per-tile block id of the 5x5 view |
+  | `crop_flags` | uint8 `(N, 25)` | per-tile flag bits of the 5x5 view |
+  | `extras_raw` | uint16 `(N, 12)` | the raw inventory/status counters |
+  | `valid` | bool `(N, 24)` | the oracle's validity mask at that state |
+  | `mask_used` | bool `(N, 24)` | the mask the policy actually acted under at that state |
+  | `action` | uint8 `(N,)` | the action sampled |
+  | `reward` | uint8 `(N,)` | the reward that step produced |
+  | `episode` | uint16 `(N,)` | episode index; rows are in step order within an episode |
+  | `episode_seed` | int64 `(E,)` | the map seed of each episode |
+
+  - Pass the first three arrays for a set of rows through `build_obs_batch` to get the exact
+    `(N, 514)` float32 observations.
+  - `mask_used` equals `valid` on some episodes and is a corrupted version of it on others.
+- The MiniDungeon implementation itself (its map generator, transition function, and validity
+  rules) is not provided, and there is no simulator you can step.
+
+## Budgets and failure
+
+- `__init__` must return within **600 seconds** of wall clock. Exceeding it, raising, or
+  failing to import scores 0 for the whole submission.
+- Per episode, the cumulative wall clock spent inside `reset` plus all `predict` calls for that
+  episode must stay under **2.0 seconds**, an average of 4 ms per step. Exceeding it ends that
+  episode, keeps the return accumulated so far, and then **terminates the predictor process, so
+  every remaining episode contributes 0**.
+- The whole evaluation run is capped at **1500 seconds**; episodes not reached contribute 0.
+- A `predict` call that raises, or returns anything that is not a bool array of shape `(24,)`,
+  ends that episode and keeps the return accumulated so far; the process keeps running and the
+  next episode starts normally. If the predictor process dies on its own, every remaining episode
+  contributes 0.
+- An all-`False` mask is replaced by a forced no-op for that step.
+
+## Environment
+
+- Installed packages: `numpy`, `scipy`, `scikit-learn`, CPU `torch`.
+- Hardware: 8 CPUs, no GPU, 14 GB of memory.
+- No network access.

tasks/vas-maskless-deployment-feasibility/task.toml

@@ -0,0 +1,57 @@
+schema_version = "1.4"
+artifacts = [ "/app/output",]
+
+[task]
+name = "bespokelabs/vas-maskless-deployment-feasibility"
+version = "1.0.0"
+description = ""
+keywords = [ "autoresearch", "machine-learning", "benchmark",]
+[[task.authors]]
+name = "Bespoke Labs"
+
+[metadata]
+category = "Model Training and ML Infrastructure"
+subcategory = "Reinforcement learning"
+task_objective = [ "Implement", "Optimize",]
+artifact_type = [ "Single script or program", "Generated output artifact",]
+expert_time_estimate_hours = 3.0
+
+[verifier]
+timeout_sec = 2400.0
+environment_mode = "separate"
+collect = []
+
+[verifier.env]
+
+[verifier.environment]
+network_mode = "no-network"
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[verifier.environment.env]
+
+[agent]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+timeout_sec = 14400.0
+user = "agent"
+
+[environment]
+network_mode = "allowlist"
+allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+build_timeout_sec = 3600.0
+os = "linux"
+cpus = 8
+memory_mb = 14336
+storage_mb = 153600
+gpus = 0
+mcp_servers = []
+
+[environment.env]
+
+[solution.env]