CUA-frontier Loading Submit a task

Physical AI · project

Lab experiments

Second stage0 tasks

Can an agent run an investigation through lab software, from planning experiments to running instruments and analysing the data, and reach a correct result within its budget and safety limits?

From a scientific or quality question, the agent plans experiments, runs them on simulated instruments through the lab's software, analyses the data, decides what to run next, and reports a result that the benchmark checks against hidden truth.

What this project asks

Much of lab work is done through software: instrument control and method editors, the instrument's own analysis, notebooks, spreadsheets and the lab's records. Lab simulators such as LabUtopia, LabDex and Labimus now give physically and chemically meaningful feedback, but they evaluate carrying out a given procedure. LabOSBench puts GUI agents on eight instrument simulators built for it, from SEM to FIB, and grades each step of the procedure; agents complete many structured steps but struggle with adjustments driven by feedback. ACED-Bench has agents choose interventions against hidden causal graphs, and finds them testing the wrong intervention and going on after the evidence was enough. Embodied First Exam's Embodied Safety Exam includes chemical-handling requests, judged on how the robot handles the hazard; no task in Embodied First Exam grades which experiment to run next, or a numeric estimate against hidden truth. Here the agent owns the investigation: it plans the experiments, runs them on simulated instruments through their software, analyses what comes back, decides what to run next, and reports a result (a property, a best recipe, a decision on a lot) that the benchmark checks against ground truth it never shows. The proposal puts this second, after the engineering track, and it may turn out to be the richer problem.

What tasks can look like

Any task that tests the question fits. Some directions:

  • Characterize: estimate an unknown property, such as a flow curve, a glass transition or a tensile modulus, to a stated tolerance.
  • Optimize: maximize a yield or a property over recipe and process settings, with a budget that an informed strategy meets and blind search does not.
  • Qualify and release: decide whether a lot or a method meets its specification, and record it the way the lab requires.
  • Work across the lab's software: a method editor, the instrument's analysis, a notebook or a spreadsheet, the lab's records, where the result is only right if the pieces agree.
  • Readings that mislead: drift, a calibration that is off, or a method that measures the wrong thing, so the agent has to notice before it reports.
  • Instruments beyond rheology: thermal analysis, a tensile tester, spectroscopy, a titration or another wet-chemistry bench.
  • A family rather than a single world: a generator that draws the hidden property or fault for each instance.

What a verifier here should establish

  • The reported result against ground truth the agent cannot see: the estimate's error, the objective reached, the decision on the lot.
  • Where the agent hands in a method or a recipe, the benchmark runs it again and gets the claimed result.
  • Safety limits and the budget held throughout.
  • The experiments were run through the lab's own software, as a person would run them. A command-line or API path to the same lab, if the task offers one, is a control and is reported separately.

Worth reporting

  • Error against the number of experiments used
  • Real readings against hidden or shuffled readings, at the same budget
  • Where a reading misleads, how often the agent catches it before it reports

For example

A chemist wants the highest yield from a batch reaction by choosing its temperature and catalyst loading. There is starting material for 12 runs, and the reactor must stay below 90 °C, where a side reaction runs away. Yield rises with both settings until the product starts to break down, so the best conditions lie on a narrow ridge. The agent sets up each run in the reactor's control software and reads the yield from the chromatography report. A 4 × 3 grid spends all 12 runs and finds 71%. An agent that spreads out its first runs, fits a model to them and spends the rest near the predicted peak finds 84%, against a best possible 86%. The verifier runs the agent's final recipe in the hidden lab, checks the reactor's temperature log against the limit, and counts the runs.

Generate a task with your agent

Give this to your coding agent in a clone of the repository. It picks a task that tests this project's question, builds it with a verifier of its own, and checks the package. You run the frontier models and open the pull request; people review it there.

Build a benchmark task for the CUA-frontier project "Lab experiments" (lab-experiments).
Repository: https://github.com/kingofspace0wzz/CUA-frontier

1. Read AGENTS.md and areas/physical-ai/lab-experiments/PROTOCOL.md: what the project asks.
2. Pick a task that tests that question. Start it with:
   python scripts/new_task.py lab-experiments <task-id>
3. Write task.md, env/ and a verifier that fits this task in verifier/, and
   state in metadata.yaml (intent:) which capability it measures. Every
   criterion the verifier scores must be stated in task.md or the env; the
   facts it checks must be reachable only through the interaction the task
   tests (for computer use, the GUI): tools you offer, such as a shell, must
   not reach them another way.
4. Calibrate the verifier: a reference solution in oracle/ it accepts,
   plausible wrong ones in negatives/ it rejects, and a check: command that
   shows both; run it with python scripts/check_task.py.
5. Have a separate red-team agent, which has not seen oracle/, try to pass
   without doing the task. Prepare its workspace with
   python scripts/red_team.py tasks/lab-experiments/<task-id>
   and give the prompt it prints to a subagent that does not see your
   conversation (in Codex, fork_turns: "none"). Never launch another agent
   CLI (codex exec, claude -p) for it. Fix what works (a guess that passes
   by chance may stay if its chance per trial is under 1%, shown in
   verifier/README.md), and record every attempt under red_team: in
   results/quality.yaml.
6. Fill in the rest of metadata.yaml, including generated_by, and run
   python scripts/validate.py tasks/lab-experiments/<task-id>
7. Stop and report what you built, the shortcuts tried, and where your
   trajectory is saved. Do not run the frontier evaluation yourself.

Tasks in this project

Claims, open pull requests and merged tasks, from the board.