agents-last-exam/agents-last-exam huggingface dataset:
Title: M&A Filing Consistency Audit
Domain: business_finance — Litigation Support & Discovery

Summary: Review four Chinese regulatory filings about the same share-transfer transaction and write an English audit report that identifies supported inconsistencies with Chinese evidence and location markers.

Task prompt:
You are reviewing four Chinese regulatory filings about the same share-transfer transaction.

## Task
Read the staged materials, cross-check the filings for factual inconsistencies, and write one
English audit report.

## Visible Inputs
- Task root: `base`
- Task brief: `base/input/task_brief.md`
- Document manifest: `base/input/document_manifest.json`
- Original PDFs: `base/input/source_documents`
- Page-labeled extracted text: `base/input/extracted_text`
- Optional Python helper: `software/python` (relative to the task root above)

## What To Deliver
Save exactly one Markdown file here:

- `base/output/audit_report.md`

## Report Requirements
1. Write in English.
2. Report every material inconsistency you can support from the staged documents.
3. For each finding, include:
   - a short English title;
   - a brief explanation of the conflict;
   - original Chinese evidence text;
   - a document name and page-number location marker.
4. Do not invent unsupported issues.
5. If you want to script against the staged files, use `software/python` from the task root.


The agent must:
Read the staged task brief, document manifest, source PDFs, and extracted-text mirrors.
Cross-check the four filings for material factual inconsistencies.
Write exactly one English Markdown audit report to `output/audit_report.md`.
For every finding, include the original Chinese evidence text and a document-plus-page location marker.
Avoid unsupported extra findings.

Software: software/python

Input files:
name: task_brief.md
format: Markdown
path: input/task_brief.md
description: Agent-visible task instructions and output contract.
name: document_manifest.json
format: JSON
path: input/document_manifest.json
description: Maps the canonical filenames to the original Chinese filings and page counts.
name: source_documents
format: PDF directory
path: input/source_documents
description: The four original staged regulatory filings in PDF form.
name: extracted_text
format: UTF-8 text directory
path: input/extracted_text
description: Page-labeled text mirrors of the four filings for reproducible search and citation.
Title: Metabase BI Dashboard
Domain: business_finance — Enterprise Analytics & Planning

Summary: Build a business analytics dashboard in Metabase using a pre-loaded SQLite database, then export key metrics as a structured JSON report.

Task prompt:
You are a business analyst building a BI dashboard in Metabase.

## Environment
- Metabase is available on this Windows machine. To start it, run the launcher script:
  `base\software\launch_metabase.bat`
  Then wait for the server to become ready and open http://localhost:3000 in the browser.
- Login credentials are in: `base\input\metabase_credentials.txt`
- The database "Business Analytics" is already connected in Metabase.

## Your Task
1. Read the task requirements at `base\input\requirements.md`
2. Read the output schema at `base\input\output_schema.json`
3. Launch Metabase using the launcher script and log in
4. Using the Metabase GUI, build the required dashboard with all 6 charts and a heading text card
5. Query the Business Analytics database to extract the required metrics
6. Save the final metrics as a JSON file conforming to the output schema

## Output
- Save your JSON report to: `base\output\dashboard_metrics.json`
- The JSON must conform to the schema in the output_schema.json
- All numerical values must be rounded to 2 decimal places
- Revenue calculations must only include orders with status = 'completed'

The agent must:
Launch Metabase via the launcher script and wait for the server to start
Log in at http://localhost:3000 with the provided credentials
Build a dashboard with 6 charts and a heading text card in the Metabase GUI
Query the Business Analytics SQLite database to extract all required metrics
Save dashboard_metrics.json conforming to the output schema to the output directory

Software: Metabase 0.54.3
Microsoft Edge

Input files:
name: Task requirements
format: md
path: input/requirements.md
description: Detailed dashboard requirements specifying 6 charts and a heading text card.
name: Output schema
format: json
path: input/output_schema.json
description: JSON Schema defining the required structure for dashboard_metrics.json.
name: Metabase credentials
format: txt
path: input/metabase_credentials.txt
description: Login credentials for the Metabase instance.
Title: PE Screening Memo 1
Domain: business_finance — Accounting & Finance

Summary: Review a staged Zscaler diligence packet and write a structured private-equity screening memo with an explicit investment recommendation.

Task prompt:
You are working on a Linux finance benchmark task.

Read these staged files first:
- `zscaler_fy2025/input/task_brief.md`
- `zscaler_fy2025/input/memo_template.md`
- `zscaler_fy2025/input/source_manifest.json`

Task-local software notes:
- `zscaler_fy2025/software/README.txt`

Your job is to write the requested private-equity screening memo for Zscaler
using only the staged packet in `zscaler_fy2025/input`.

Write exactly one required file:
- `zscaler_fy2025/output/screening_memo.md`

Output requirements:
- filename must be exactly `screening_memo.md`
- output must be valid UTF-8 Markdown
- follow the structure from `memo_template.md`
- make an explicit `Go`, `No-Go`, or `Hold / Needs More Diligence` recommendation

Constraints:
1. Use only the staged packet.
2. Do not use web search.
4. Write only your final memo under `zscaler_fy2025/output`.


The agent must:
Read the staged brief, memo template, and source manifest before starting.
Use only the staged Zscaler packet and do not use web search.
Write a Markdown screening memo that follows the visible template exactly enough to preserve the required section structure.
Make an explicit `Go`, `No-Go`, or `Hold / Needs More Diligence` recommendation and support it with packet-grounded reasoning.
Save the final memo as `output/screening_memo.md`.

Software: Python

Input files:
name: task_brief.md
format: Markdown
path: input/task_brief.md
description: Primary agent-visible benchmark brief with the output contract and workflow constraints.
name: memo_template.md
format: Markdown
path: input/memo_template.md
description: Required memo structure and section template.
name: source_manifest.json
format: JSON
path: input/source_manifest.json
description: Human-readable inventory of the visible diligence packet.
name: q2_2025_earnings_release.pdf/.txt
format: PDF and plaintext extract
path: input/q2_2025_earnings_release.*
description: Official Zscaler IR Q2 FY2025 results release.
name: q2_2025_earnings_presentation.pdf/.txt
format: PDF and plaintext extract
path: input/q2_2025_earnings_presentation.*
description: Official Zscaler IR Q2 FY2025 earnings presentation.
name: q3_2025_earnings_release.pdf/.txt
format: PDF and plaintext extract
path: input/q3_2025_earnings_release.*
description: Official Zscaler IR Q3 FY2025 results release.
name: q3_2025_earnings_presentation.pdf/.txt
format: PDF and plaintext extract
path: input/q3_2025_earnings_presentation.*
description: Official Zscaler IR Q3 FY2025 earnings presentation.
name: zscaler_10k_2025.pdf/.txt
format: PDF and plaintext extract
path: input/zscaler_10k_2025.*
description: Official FY2025 Zscaler Form 10-K plus plaintext extract.
Title: SaaS One-Pager Brand Refresh
Domain: business_finance — Graphic, Visual & Product Design

Summary: Rebuild a flattened SaaS one-pager as an editable single-slide PowerPoint on Windows, apply the staged NorthstarOS rebrand changes, and export both a PPTX and a PNG.

Task prompt:
You are editing a SaaS one-pager on a Windows VM.

## Variant
`base`: NorthstarOS one-pager brand refresh

## Runtime Entry Point
- Open PowerPoint from: `base\software\OpenPowerPoint.bat`

## Visible Inputs
- Source one-pager PNG: `base\input\original_onepager.png`
- Edit brief: `base\input\edit_request.txt`
- Brand guide PDF: `base\input\brand_guide.pdf`
- KPI data CSV: `base\input\metrics.csv`
- Chart data CSV: `base\input\chart_data.csv`
- Replacement assets directory: `base\input\assets`
- Task brief: `base\input\task_brief.md`
- Output contract: `base\input\output_contract.json`

## What You Must Do
1. Read the staged brief and input files.
2. Rebuild the one-pager as a meaningfully editable single-slide PowerPoint.
3. Apply the requested NorthstarOS brand refresh while preserving the overall composition.
4. Save the editable PowerPoint exactly to `base\output\edited_onepager.pptx`.
5. Export the final slide exactly to `base\output\edited_onepager.png`.

## Output Requirements
- The `.pptx` must remain meaningfully editable.
- Save only the final required deliverables inside `base\output`.
- Do not modify files under `input/`.


The agent must:
Read the staged source one-pager, edit brief, brand guide, KPI CSV, chart CSV, and asset bundle from `input/`.
Rebuild the page as a meaningfully editable single-slide PowerPoint on Windows.
Apply the requested NorthstarOS brand refresh while preserving the overall composition.
Save exactly `output/edited_onepager.pptx` and `output/edited_onepager.png`.

Software: Microsoft PowerPoint

Input files:
name: original_onepager.png
format: PNG image
path: input/original_onepager.png
description: Flattened source one-pager to recreate and refresh.
name: edit_request.txt
format: text
path: input/edit_request.txt
description: Natural-language NorthstarOS brand refresh request.
name: brand_guide.pdf
format: PDF
path: input/brand_guide.pdf
description: Visible palette and style direction for the refresh.
name: metrics.csv
format: CSV
path: input/metrics.csv
description: Replacement KPI values for the three metric cards.
name: chart_data.csv
format: CSV
path: input/chart_data.csv
description: Replacement line-chart data for the throughput section.
name: assets
format: asset directory
path: input/assets
description: Visible logo, hero, headshot, QR, and icon assets, including original and replacement variants where supplied.
name: task_brief.md
format: Markdown
path: input/task_brief.md
description: Benchmark-authored solve-time instructions.
name: output_contract.json
format: JSON
path: input/output_contract.json
description: Visible output filename contract.
Title: SSE Northbound Programmatic Trading Research
Domain: business_finance — Compliance & Regulatory

Summary: Answer three closed-book Shanghai Stock Exchange reporting questions from staged Chinese source documents and return a structured JSON memo with Chinese citations and evidence.

Task prompt:
You are acting as a regulatory consultant on Shanghai Stock Exchange Northbound programmatic-trading reporting.

## Closed-Book Rule

- Use only the staged materials under `base/input`.
- Do not use outside web search or external regulatory knowledge.

## Inputs

- Task brief: `base/input/task_brief.md`
- Question set: `base/input/question_set.json`
- Output contract: `base/input/output_contract.json`
- Document manifest: `base/input/document_manifest.json`
- Original source files: `base/input/source_documents`
- Extracted UTF-8 text mirrors: `base/input/extracted_text`

## Your Task

Answer the three client questions in the staged brief:

1. whether leverage-related information must be reported separately through each broker for same-LEI accounts;
2. whether the staged rules provide specific numerical amounts for `流量费` and `撤单费`;
3. whether a French firm can report using only the original foreign-language software name.

## Deliverable

Write exactly one JSON file here:

- `base/output/research_answers.json`

Each top-level question key must contain:

- `conclusion`: exactly `Yes`, `No`, or `Unknown`
- `citation_document`: the Simplified Chinese source document name you rely on
- `evidence_snippet`: an exact Simplified Chinese excerpt copied from the staged source
- `answer_text`: a short English explanation


The agent must:
Read the staged task brief, question set, output contract, document manifest, source documents, and extracted-text mirrors.
Answer all three client questions using only the staged Shanghai Stock Exchange materials.
Write exactly one JSON file to `output/research_answers.json`.
For each question, provide a `Yes`/`No`/`Unknown` conclusion, a Chinese citation, an exact Chinese evidence excerpt, and a short English explanation.
Stay closed-book and do not use outside web search or external regulatory knowledge.

Software: Python

Input files:
name: task_brief.md
format: Markdown
path: input/task_brief.md
description: Agent-visible task instructions and the three client questions.
name: question_set.json
format: JSON
path: input/question_set.json
description: Structured list of the three required research questions and allowed conclusion labels.
name: output_contract.json
format: JSON
path: input/output_contract.json
description: Defines the required output filename, top-level keys, and per-question JSON fields.
name: document_manifest.json
format: JSON
path: input/document_manifest.json
description: Maps the staged Chinese source files to their citation aliases.
name: source_documents
format: DOCX/XLSX directory
path: input/source_documents
description: The ten original staged Shanghai Stock Exchange source files.
name: extracted_text
format: UTF-8 text directory
path: input/extracted_text
description: Search-friendly text mirrors of the staged Chinese source files.
Title: Taxform 4 1
Domain: business_finance — Accounting & Finance

Summary: Prepare a U.S. tax return from staged wage documents and instructions, then save the required JSON outputs.

Task prompt:
You are preparing a U.S. tax return inside a browser-based local task environment.

## Variant
`variant_1`: W-2 income with a single Form 1040 output.

## Runtime Entry Points
- Start the local HTTP server by running: `variant_1\software\start_http_server.bat`
- Read the taxpayer instructions at: `variant_1\input\instruction.txt`

## Source Forms To Read
These pages are prefilled reference documents. Read them, but do not edit them.
- Form W-2 — Wage and Tax Statement: `http://localhost:8080/forms/formw2.html?data=/`

## Output Forms To Complete
Fill these blank return pages in the browser, then click `Save Results` on each one.
- Form 1040 — U.S. Individual Income Tax Return: `http://localhost:8080/forms/form1040.html`

## What You Must Do
1. Run `variant_1\software\start_http_server.bat` to serve the staged `input/` directory on `http://localhost:8080`.
2. Read `variant_1\input\instruction.txt` carefully.
3. Open every source form listed above and extract the needed values.
4. Open every output form listed above and complete the tax return.
5. Click `Save Results` on each required output form.
6. Move the downloaded JSON file(s) into `variant_1\output`.

## Required Final Output Files
Place these exact files in `variant_1\output`:
- `form1040_output.json`

The agent must:
Launch the task-local HTTP server from `software/start_http_server.bat`, which serves the staged `input/` directory at `http://localhost:8080`.
Read `input/instruction.txt` and the staged source forms listed in `input/README.md`, combining free-text tax instructions with values shown on the pre-filled W-2 / 1099 forms.
Fill the blank output form pages (`form1040.html`, and `form1040s1.html` for `variant_5`) in the browser, then click `Save Results` on each output form so the browser downloads the required JSON outputs.

Software: Python
Chrome

Input files:
name: README.md
format: Markdown
path: input/README.md
description: Source-authored setup and page-order instructions
name: instruction.txt
format: UTF-8 text
path: input/instruction.txt
description: Taxpayer scenario, filing rules, and calculation instructions
name: forms/
format: HTML, PDF, JS, CSS
path: input/forms/...
description: Interactive tax forms and static assets served locally
name: *_input.json
format: JSON
path: input/*.json
description: Source-form payloads read via the ?data=/ query string
Title: Branch-and-Bound ATSP Solver
Domain: computing_math — Mathematical & Operations Research

Summary: Implement a Python branch-and-bound solver for deterministic asymmetric TSP instances and report certified results across three tiers.

Task prompt:
You are working on a Linux VM.

## Task Directory
`base`

## Visible Inputs
- Task prompt: `base/input/TASK_PROMPT.md`
- ATSP problem specification: `base/input/problem_spec.md`
- Runtime manifest: `base/input/runtime_env/pyproject.toml`
- Python entry point with task dependencies: `base/software/python`

## Your Task
Implement a branch-and-bound solver for the asymmetric travelling salesman
problem described in the problem specification. Solve the 12-city and 20-city
instances to proven optimality, solve the 35-city instance to at most 0.5%
optimality gap, and write the required JSON report to:

`base/output/results.json`

Use only Python, NumPy, and SciPy. Do not use external optimization solvers or
TSP packages. Do not modify files under `base/input`.


The agent must:
Regenerate the deterministic 3D city coordinates for the 12, 20, and 35 city tiers.
Implement branch-and-bound and assignment-relaxation based lower bounds without external optimization solvers.
Write a valid `results.json` containing tours, costs, bounds, gaps, node counts, and runtime metrics.

Software: Python
NumPy
SciPy

Input files:
name: problem_spec.md
format: markdown
path: input/problem_spec.md
description: Authoritative ATSP problem statement and output schema.
name: TASK_PROMPT.md
format: markdown
path: input/TASK_PROMPT.md
description: Normalized solve-time instructions staged for the agent.
name: pyproject.toml
format: toml
path: input/runtime_env/pyproject.toml
description: Solve-time Python dependency manifest for NumPy and SciPy.
Title: CFR Game Theory Equilibrium
Domain: computing_math — Mathematical & Operations Research

Summary: Implement exact and regret-minimization solvers for three zero-sum games and write one combined JSON output.

Task prompt:
You are working on a Linux VM.

## Your Task
Implement equilibrium solvers for three progressively harder two-player zero-sum games and save one combined `results.json`.

## Visible Input
- Authoritative problem specification: `base/input/problem_spec.md`
- Solve-time runtime manifest: `base/input/runtime_env/pyproject.toml`
- Solve-time runtime lockfile: `base/input/runtime_env/uv.lock`

## Runtime Entry Points
- Bootstrap the staged NumPy runtime with `base/software/bootstrap_runtime.sh`
- Run Python with staged task dependencies using `base/software/python_with_task_deps.sh`

## What You Must Produce
Write exactly one file at `base/output/results.json`.

The JSON must contain top-level keys `tier1`, `tier2`, and `tier3`:
- `tier1`: matrix-game equilibrium value, row/column mixed strategies, and row/column support indices
- `tier2`: Kuhn poker CFR iterations, final exploitability, average strategy, game value estimate, and information-set count
- `tier3`: 4-rank Leduc MCCFR iterations, final exploitability, full average strategy map, information-set count, and exact game parameters

## Rules
- Read `base/input/problem_spec.md` first and follow it closely.
- Do not modify any files under `base/input`.
- Do not write outside `base/output`.
- Use only the staged local inputs and the software already available on this VM.


The agent must:
Read the staged problem specification and implement all three tiers of the benchmark.
Use the staged runtime wrappers to install and run the NumPy-only solve-time environment if needed.
Return one combined `results.json` containing Tier 1 matrix-game, Tier 2 Kuhn CFR, and Tier 3 Leduc MCCFR outputs.

Software: Python
uv
NumPy

Input files:
name: Problem specification
format: Markdown
path: input/problem_spec.md
description: Agent-visible task specification for all three game-solving tiers.
name: Runtime manifest
format: pyproject.toml
path: input/runtime_env/pyproject.toml
description: Staged solve-time Python dependency manifest.
name: Runtime lockfile
format: uv.lock
path: input/runtime_env/uv.lock
description: Locked solve-time dependency set for the staged runtime.
name: Bootstrap wrapper
format: shell script
path: software/bootstrap_runtime.sh
description: Agent-visible helper for creating the staged runtime environment.
name: Python wrapper
format: shell script
path: software/python_with_task_deps.sh
description: Agent-visible helper for running Python with the staged task dependencies.
Title: Clustered-Cyclic Code Circuit Simulation
Domain: computing_math — Quantum Computing

Summary: Reproduce circuit-level logical failure-rate data for three clustered-cyclic CSS quantum error-correcting codes using the supplied construction notes and simulation grid.

Task prompt:
You are working on a Linux VM.

## Variant
`base`: Three clustered-cyclic CSS codes with QUITS/Stim circuit-level memory simulation.

## Input Files
- Task notes: `base/input/cc_codes_quits_extraction.tex`
- Simulation grid: `base/input/simulation_grid.csv`
- Output requirements: `base/input/output_requirements.txt`
- Python runtime manifest: `base/input/runtime_env/pyproject.toml`

## Your Task
Reproduce the circuit-level memory-simulation logical failure-rate table for the three clustered-cyclic CSS codes described in the task notes.

Use the staged notes to extract the code construction, QUITS repeated-syndrome-extraction workflow, direction-aware edge-coloring schedule, Stim detector-error-model workflow, BP+OSD decoder settings, and logical failure-rate formulas.

Run every row in the simulation grid. For each row, report the logical failure count, total logical failure probability, per-round logical failure rate, and per-logical-qubit per-round logical failure rate.

You may install the task-specific open-source Python dependencies from `input/runtime_env/pyproject.toml` or `input/requirements.txt`.

## Output
Write the final CSV here:
- `base/output/logical_error_rates_3codes.csv`


The agent must:
Read `input/cc_codes_quits_extraction.tex`, `input/simulation_grid.csv`, and `input/output_requirements.txt`.
Install or inspect the open-source Python runtime from `input/runtime_env/pyproject.toml` or `input/requirements.txt`.
Construct and simulate the `[24,8,3]`, `[40,8,5]`, and `[56,8,7]` clustered-cyclic CSS code cases from the supplied notes.
Compute `num_failures`, `p_logical`, `lfr_per_round`, and `lfr_per_round_per_qubit` for every row in the simulation grid.
Save the final CSV as `output/logical_error_rates_3codes.csv`.

Software: Python
Stim
ldpc
QUITS
NumPy
pandas

Input files:
name: cc_codes_quits_extraction.tex
format: tex
path: input/cc_codes_quits_extraction.tex
description: Agent-facing construction and simulation notes from the submitter.
name: simulation_grid.csv
format: csv
path: input/simulation_grid.csv
description: The required code, physical error-rate, round-count, and shot-count grid.
name: output_requirements.txt
format: txt
path: input/output_requirements.txt
description: The required output CSV schema and derived-rate formulas.
name: pyproject.toml
format: toml
path: input/runtime_env/pyproject.toml
description: Open-source Python dependency manifest for the simulation runtime.