EVALUATION_GUIDE.md

# Running an Agent on MATTER-604

This guide defines the provider-neutral solve protocol for MATTER-604. It
explains what an evaluated Agent receives, how task files are prepared, and how
to retain an answer, artifacts, and a native execution trace for later scoring.

The evaluated Agent must have access only to this public task repository and
the software or compute services declared for the run. Do not expose the
private evaluator, reference answers, rubrics, Gold files, evaluator access
tokens, or previous answers to the Agent.

## 1. Record the run configuration

Before solving any task, record:

- Agent name and version;
- model name and exact model version when available;
- system prompt, enabled skills, tools, and permission policy;
- container image or operating-system environment;
- scientific-software and command-line tool versions;
- start time and any task-level timeout;
- whether the Agent or model may previously have seen MATTER questions or
  answers.

Keep the Agent's native system prompt, reasoning loop, and tool interface. To
compare Agents, use the same task preparation and the same public task content;
do not rewrite a question for one Agent but not the others.

## 2. Select one task

Each line of `data/test.jsonl` is one independent task:

```json
{
  "task_id": "...",
  "capability": "...",
  "domain": "...",
  "prompt": "...",
  "tags": [],
  "data_files": []
}
```

Use `task_id` as the stable identity. `prompt` is the task statement delivered
to the Agent. `data_files` declares every task input; do not add undeclared
benchmark files to the workspace.

## 3. Create an isolated workspace

Create a fresh directory for each task. A recommended layout is:

```text
runs/<agent>/<task_id>/
├── workspace/          # the Agent's working directory
├── prompt.txt         # exact effective user prompt
├── final_answer.txt  # final response returned by the Agent
├── trace/             # native conversation and tool events
├── submission.json   # one schema-valid submission record
└── run_metadata.json # full reproducibility metadata
```

Do not reuse a workspace between tasks. Do not let parallel tasks share mutable
files, conversation state, shell history, or result directories.

## 4. Stage the declared input files

For each entry in `data_files`:

1. Verify its `size_bytes` and `sha256` before the Agent starts.
2. For `distribution=bundled`, copy the file from its repository-relative
   `path` into the task workspace root using the source basename.
3. Replace occurrences of the repository path in the task prompt with that
   basename.
4. Append one neutral line listing the staged filenames:

   `[The following data files are already in your working directory: \`file1\`, \`file2\`]`

For `distribution=restricted`, obtain the file through the stated lawful
`acquisition` route, place it at the declared path outside version control,
verify the declared size and SHA-256, and then stage it in the same way. Do not
substitute a different pseudopotential, paper, or file merely because it has a
similar name.

The file staging above matches the canonical MATTER runner. If an adapter uses
a different workspace layout, it must preserve the filenames visible to the
Agent and the effective prompt text.

## 5. Construct the effective prompt

Start from the record's `prompt`, apply only the path rewriting and staged-file
listing described above, and then add any run-wide safety or compute guidance
identically for every applicable Agent. Save the exact UTF-8 text as
`prompt.txt`.

Compute `metadata.prompt_sha256` from the exact bytes delivered as the user
prompt, after all additions and path rewriting:

```bash
shasum -a 256 prompt.txt
```

Do not add answer hints, scoring criteria, expected values, tolerances, or
information obtained from the evaluator.

## 6. Run the Agent

Launch the Agent with `workspace/` as its working directory and provide the
contents of `prompt.txt` as the task input. Allow the Agent to use only the
tools, software, network access, and remote-compute routes declared in the run
configuration.

Capture the Agent's native conversation and tool events from start to finish.
The trace should retain commands, software calls, job identifiers, failures,
retries, and result extraction. Redact credentials, authorization headers, and
authentication caches; do not remove ordinary scientific failures or failed
attempts.

Save the Agent's final response verbatim in `final_answer.txt`. Preserve files
created by the Agent before running the evaluator. Evaluation must not modify
the recorded solve trace or make post-hoc checks appear to be part of the
Agent's original work.

## 7. Bohr CLI tasks

Fifty-three tasks carry the `bohr-cli` tag. A complete comparable run must make
a real, authenticated `bohr` executable available while those tasks are being
solved. The evaluation adapter must audit the CLI process and retain
`bohr_cli_receipts.jsonl` as execution evidence; the gated evaluator package
contains the canonical audit implementation.
The published three-Agent environment used Node.js 22 and Bohr CLI 2.5.17:

```bash
npm install -g @dptech-corp/bohr-cli@2.5.17
bohr version -o json
```

Keep Bohrium credentials and authentication caches outside the workspace and
outside all submitted artifacts. Record the CLI version and the project used
for the run in protected operator metadata; never place access keys in the
prompt, trace, or submission. Installing Bohr CLI after solving cannot recreate
missing execution receipts.

The remaining 551 tasks do not have a benchmark-wide mandatory Bohr CLI
dependency. They may still use remote compute when the individual task and the
declared run environment permit it.

## 8. Build one submission record

Create one JSON object conforming to `submission.schema.json`:

```json
{
  "task_id": "TASK_ID",
  "final_answer": "verbatim final response",
  "artifacts": [
    {
      "path": "workspace/result.ext",
      "sha256": "64-lowercase-hex-digits"
    }
  ],
  "trace_path": "trace/trace.jsonl",
  "metadata": {
    "agent": "agent name and version",
    "model": "model name and version",
    "prompt_sha256": "64-lowercase-hex-digits",
    "runtime": "container or host environment",
    "started_at": "ISO-8601 timestamp",
    "finished_at": "ISO-8601 timestamp"
  }
}
```

Artifact paths must be relative to the task result directory. Hash the exact
submitted bytes. List only files produced or deliberately retained as evidence
for this task; exclude credentials, caches, unrelated downloads, and evaluator
files.

Validate the record locally before submission:

```bash
python -m pip install jsonschema
python - submission.schema.json runs/AGENT/TASK_ID/submission.json <<'PY'
import json
import sys
from pathlib import Path
from jsonschema import Draft202012Validator

schema = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
record = json.loads(Path(sys.argv[2]).read_text(encoding="utf-8"))
Draft202012Validator(schema).validate(record)
print("submission schema: PASS")
PY
```

## 9. Score only after the solve is frozen

Freeze the answer, artifacts, trace, and metadata before scoring. Send the
submission bundle to the evaluator operator or service designated for the run.
The evaluated Agent must not receive evaluator output and then revise its
answer within the same attempt.

Scores produced by the canonical MatMaster-DP private evaluator may be reported
as official MATTER scores. Scores produced with the separately gated evaluator
must be labeled `self-hosted MATTER-604`, together with the public dataset
revision, evaluator commitment, Agent/model configuration, and runtime.

## 10. Batch-run checklist

For every one of the 604 task IDs, verify that:

- a fresh workspace was used;
- the effective prompt and its SHA-256 were retained;
- all declared inputs were staged and hash-checked;
- the final answer was saved verbatim;
- artifact hashes match the submitted files;
- a native trace and reproducibility metadata were retained;
- no private evaluator content or credentials entered the Agent environment;
- Bohr receipts exist for applicable `bohr-cli` executions;
- the submission record passes `submission.schema.json`.