diff --git a/tasks/0001_042_1042725_qa_5/instruction.md b/tasks/0001_042_1042725_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0d5867bc39da273a835882a01cf8f8ea3ae99c33
--- /dev/null
+++ b/tasks/0001_042_1042725_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- marathon_results_2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which two countries have the most top 100 male marathon runners after the USA in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the two country names.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_042_1042725_qa_5/task.toml b/tasks/0001_042_1042725_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..34fa2e31a5120dc0a63a5aaefe5416df63f4c5ed
--- /dev/null
+++ b/tasks/0001_042_1042725_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_042_1042725_qa_5"
+description = "Which two countries have the most top 100 male marathon runners after the USA in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/042/1042725.ipynb_qa_5"
+kaggle_dataset_name = "rojour/boston-results"
+gold_answer = "Kenya, Ethiopia"
+reward_mode_initial = "list"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rojour__boston-results"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rojour/boston-results"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Kenya, Ethiopia"
+QUESTION = "Which two countries have the most top 100 male marathon runners after the USA in the dataset?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_090_1090499_qa_1/instruction.md b/tasks/0001_090_1090499_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..addf68c2441b80730e5d9403374182c912ee2fc6
--- /dev/null
+++ b/tasks/0001_090_1090499_qa_1/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- xAPI-Edu-Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which two nationalities have the highest representation in the dataset based on the analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the two nationalities, in the order given.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_090_1090499_qa_1/task.toml b/tasks/0001_090_1090499_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..be740c89c282aeaaa6672f162ef3cf4b61c0eb19
--- /dev/null
+++ b/tasks/0001_090_1090499_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_090_1090499_qa_1"
+description = "Which two nationalities have the highest representation in the dataset based on the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/090/1090499.ipynb_qa_1"
+kaggle_dataset_name = "aljarah/xAPI-Edu-Data"
+gold_answer = "Kuwait, Jordan"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "aljarah__xAPI-Edu-Data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "aljarah/xAPI-Edu-Data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Kuwait, Jordan"
+QUESTION = "Which two nationalities have the highest representation in the dataset based on the analysis?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_155_1155264_qa_5/instruction.md b/tasks/0001_155_1155264_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d9d4e346c80bbc422e95cad0f0eab9ba9e79f27c
--- /dev/null
+++ b/tasks/0001_155_1155264_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common instance type in the south zone identified through the analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_155_1155264_qa_5/task.toml b/tasks/0001_155_1155264_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e0bfdfdd31b52d4e7f1754c34200aaed2cb7b488
--- /dev/null
+++ b/tasks/0001_155_1155264_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0001_155_1155264_qa_5"
+description = "What is the most common instance type in the south zone identified through the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/155/1155264.ipynb_qa_5"
+kaggle_dataset_name = "noqcks/aws-spot-pricing-market"
+gold_answer = "m4.large"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "noqcks__aws-spot-pricing-market"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "noqcks/aws-spot-pricing-market"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "m4.large"
+QUESTION = "What is the most common instance type in the south zone identified through the analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_257_1257756_qa_1/instruction.md b/tasks/0001_257_1257756_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..98280d87443350d74d9d66918cb49257f27ac4ba
--- /dev/null
+++ b/tasks/0001_257_1257756_qa_1/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- FMEL_Dataset.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average percentage of matches won by the home team across all seasons in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Express the value as a percentage (e.g. 95.5), not a fraction.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_257_1257756_qa_1/task.toml b/tasks/0001_257_1257756_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bad2204e56ddf7b849651473bd5b4412537450a0
--- /dev/null
+++ b/tasks/0001_257_1257756_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_257_1257756_qa_1"
+description = "What is the average percentage of matches won by the home team across all seasons in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/257/1257756.ipynb_qa_1"
+kaggle_dataset_name = "ricardomoya/football-matches-of-spanish-league"
+gold_answer = "51.16"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ricardomoya__football-matches-of-spanish-league"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ricardomoya/football-matches-of-spanish-league"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "51.16"
+QUESTION = "What is the average percentage of matches won by the home team across all seasons in the dataset?"
+REWARD_MODE = "flexible"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_277_1277058_qa_5/instruction.md b/tasks/0001_277_1277058_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e1269a8d8556f771995d204e9312dc6db5ddc2a8
--- /dev/null
+++ b/tasks/0001_277_1277058_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- us_companies.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which year had the second-highest number of companies founded, and how many companies were founded that year?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_277_1277058_qa_5/task.toml b/tasks/0001_277_1277058_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..85b36a8581feec0bc05a35901008c632de6e0fc9
--- /dev/null
+++ b/tasks/0001_277_1277058_qa_5/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0001_277_1277058_qa_5"
+description = "Which year had the second-highest number of companies founded, and how many companies were founded that year?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/277/1277058.ipynb_qa_5"
+kaggle_dataset_name = "govlab/open-data-500-companies"
+gold_answer = "2010 and 50"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "govlab__open-data-500-companies"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "govlab/open-data-500-companies"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2010 and 50"
+QUESTION = "Which year had the second-highest number of companies founded, and how many companies were founded that year?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0001_312_1312239_qa_2/instruction.md b/tasks/0001_312_1312239_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3f2d537943d775e394bc6215cd0a37f13fa86e9a
--- /dev/null
+++ b/tasks/0001_312_1312239_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- 2015.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which region has the highest average Happiness Score when grouping by geographic regions?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_312_1312239_qa_2/task.toml b/tasks/0001_312_1312239_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0b51b77aeb8f4569e30a5fd5151b00412dfd2183
--- /dev/null
+++ b/tasks/0001_312_1312239_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_312_1312239_qa_2"
+description = "Which region has the highest average Happiness Score when grouping by geographic regions?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/312/1312239.ipynb_qa_2"
+kaggle_dataset_name = "unsdsn/world-happiness"
+gold_answer = "Australia and New Zealand"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "unsdsn__world-happiness"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "unsdsn/world-happiness"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Australia and New Zealand"
+QUESTION = "Which region has the highest average Happiness Score when grouping by geographic regions?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_330_1330281_qa_3/instruction.md b/tasks/0001_330_1330281_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cee0dd7ac0d809d6308c38e6bae87db65fff2a44
--- /dev/null
+++ b/tasks/0001_330_1330281_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- shot_logs.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the base shot success rate across all shots in the dataset, regardless of contextual factors?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_330_1330281_qa_3/task.toml b/tasks/0001_330_1330281_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8fdd3d0948b2f35336d6c41cb0217bcc6b8f16fe
--- /dev/null
+++ b/tasks/0001_330_1330281_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_330_1330281_qa_3"
+description = "What is the base shot success rate across all shots in the dataset, regardless of contextual factors?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/330/1330281.ipynb_qa_3"
+kaggle_dataset_name = "dansbecker/nba-shot-logs"
+gold_answer = "45.2139"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "dansbecker__nba-shot-logs"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "dansbecker/nba-shot-logs"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "45.2139"
+QUESTION = "What is the base shot success rate across all shots in the dataset, regardless of contextual factors?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_330_1330281_qa_4/instruction.md b/tasks/0001_330_1330281_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b78dd1829038c3dc645bb128c614862a82ad8501
--- /dev/null
+++ b/tasks/0001_330_1330281_qa_4/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- shot_logs.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How does the 1st period’s shot success rate compare to the 4th period’s shot success rate during regulation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <period>, <percentage> pairs, comma-separated, with the period label first and the percentage as a plain number with two decimals followed by a percent sign (e.g., 46.05%).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_330_1330281_qa_4/task.toml b/tasks/0001_330_1330281_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..40889015676a15ff0d24cc768edccb9dfc260d43
--- /dev/null
+++ b/tasks/0001_330_1330281_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_330_1330281_qa_4"
+description = "How does the 1st period’s shot success rate compare to the 4th period’s shot success rate during regulation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/330/1330281.ipynb_qa_4"
+kaggle_dataset_name = "dansbecker/nba-shot-logs"
+gold_answer = "1st period 46.0528%, 4th period 44.0099%"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "dansbecker__nba-shot-logs"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "dansbecker/nba-shot-logs"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1st period 46.0528%, 4th period 44.0099%"
+QUESTION = "How does the 1st period’s shot success rate compare to the 4th period’s shot success rate during regulation?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_352_1352372_qa_5/instruction.md b/tasks/0001_352_1352372_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..abe7a9fe4fb16b6b3ee721ad0b427a6a3b944e81
--- /dev/null
+++ b/tasks/0001_352_1352372_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- celebrity_deaths_4.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many celebrities in the dataset died as a result of accidents?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_352_1352372_qa_5/task.toml b/tasks/0001_352_1352372_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4cf48c9d4cba5ee5e14ee34e356631682898b699
--- /dev/null
+++ b/tasks/0001_352_1352372_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_352_1352372_qa_5"
+description = "How many celebrities in the dataset died as a result of accidents?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/352/1352372.ipynb_qa_5"
+kaggle_dataset_name = "hugodarwood/celebrity-deaths"
+gold_answer = "141"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "hugodarwood__celebrity-deaths"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "hugodarwood/celebrity-deaths"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "141"
+QUESTION = "How many celebrities in the dataset died as a result of accidents?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_361_1361614_qa_1/instruction.md b/tasks/0001_361_1361614_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e279f226eee25263fdeb947c88d0acd892a082ac
--- /dev/null
+++ b/tasks/0001_361_1361614_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- GlobalLandTemperaturesByMajorCity.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which Indian city has the highest temperature difference between its maximum and minimum recorded temperatures in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_361_1361614_qa_1/task.toml b/tasks/0001_361_1361614_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..91f5bdd8229932ec72cae2053b1daaed895f02aa
--- /dev/null
+++ b/tasks/0001_361_1361614_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_361_1361614_qa_1"
+description = "Which Indian city has the highest temperature difference between its maximum and minimum recorded temperatures in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/361/1361614.ipynb_qa_1"
+kaggle_dataset_name = "berkeleyearth/climate-change-earth-surface-temperature-data"
+gold_answer = "New Delhi"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "berkeleyearth__climate-change-earth-surface-temperature-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "berkeleyearth/climate-change-earth-surface-temperature-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "New Delhi"
+QUESTION = "Which Indian city has the highest temperature difference between its maximum and minimum recorded temperatures in the dataset?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_445_1445407_qa_4/instruction.md b/tasks/0001_445_1445407_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1b7f3f953e9e6cde1d22aa561acb58034402c7e5
--- /dev/null
+++ b/tasks/0001_445_1445407_qa_4/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- actual.csv
+- data_set_ALL_AML_independent.csv
+- data_set_ALL_AML_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of patients in the test set used for evaluating the KNN model's performance?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_445_1445407_qa_4/task.toml b/tasks/0001_445_1445407_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..84fd0b990f34b14acd595ecfc8194b80ebeabd4a
--- /dev/null
+++ b/tasks/0001_445_1445407_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_445_1445407_qa_4"
+description = "What is the total number of patients in the test set used for evaluating the KNN model's performance?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/445/1445407.ipynb_qa_4"
+kaggle_dataset_name = "crawford/gene-expression"
+gold_answer = "34"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "crawford__gene-expression"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crawford/gene-expression"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "34"
+QUESTION = "What is the total number of patients in the test set used for evaluating the KNN model's performance?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_452_1452536_qa_1/instruction.md b/tasks/0001_452_1452536_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9c530de074673db6673eef12ec8c69be7d6cd9d0
--- /dev/null
+++ b/tasks/0001_452_1452536_qa_1/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- database.sqlite
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which team had the lowest True Performance in the dataset, and what was their True Performance value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <team>, <value> (comma-separated, team name first, keep the negative sign and decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_452_1452536_qa_1/task.toml b/tasks/0001_452_1452536_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..39bcadfdfeec0a28b80535a7e4cb2a8aad0e3808
--- /dev/null
+++ b/tasks/0001_452_1452536_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0001_452_1452536_qa_1"
+description = "Which team had the lowest True Performance in the dataset, and what was their True Performance value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/452/1452536.ipynb_qa_1"
+kaggle_dataset_name = "hugomathien/soccer"
+gold_answer = "Borussia Dortmund in the 2014/2015 season with -24.03 points."
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "hugomathien__soccer"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "hugomathien/soccer"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "St. Mirren, with a True Performance value of -38.33"
+QUESTION = "Which team had the lowest True Performance in the dataset, and what was their True Performance value?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_532_1532619_qa_4/instruction.md b/tasks/0001_532_1532619_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4b68d779da34b31b56402d2d78700020ca4d5655
--- /dev/null
+++ b/tasks/0001_532_1532619_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- indian_liver_patient.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference in ROC AUC scores between the optimized SVM model (0.577) and the optimized Random Forest model (0.692) on the test dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_532_1532619_qa_4/task.toml b/tasks/0001_532_1532619_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3f217937b6b5c619760d272c82db7fb66754d32c
--- /dev/null
+++ b/tasks/0001_532_1532619_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_532_1532619_qa_4"
+description = "What is the difference in ROC AUC scores between the optimized SVM model (0.577) and the optimized Random Forest model (0.692) on the test dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/532/1532619.ipynb_qa_4"
+kaggle_dataset_name = "uciml/indian-liver-patient-records"
+gold_answer = "0.115"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__indian-liver-patient-records"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/indian-liver-patient-records"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.115"
+QUESTION = "What is the difference in ROC AUC scores between the optimized SVM model (0.577) and the optimized Random Forest model (0.692) on the test dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_593_1593034_qa_5/instruction.md b/tasks/0001_593_1593034_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1ff7f4181486cbe7fe320edfa2bfefef7a0444de
--- /dev/null
+++ b/tasks/0001_593_1593034_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- wineQualityReds.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean alcohol content of all wines in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_593_1593034_qa_5/task.toml b/tasks/0001_593_1593034_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b4581b722a51ba32df4db95264458b6ba66f1ac2
--- /dev/null
+++ b/tasks/0001_593_1593034_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_593_1593034_qa_5"
+description = "What is the mean alcohol content of all wines in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/593/1593034.ipynb_qa_5"
+kaggle_dataset_name = "piyushgoyal443/red-wine-dataset"
+gold_answer = "10.422983"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "piyushgoyal443__red-wine-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "piyushgoyal443/red-wine-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "10.422983"
+QUESTION = "What is the mean alcohol content of all wines in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_636_1636611_qa_2/instruction.md b/tasks/0001_636_1636611_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2d9434d99510a25feec81301bbb6cdc146558de5
--- /dev/null
+++ b/tasks/0001_636_1636611_qa_2/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- iclr2017_papers.csv
+- iclr2017_conversations.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most commonly assigned review rating in the ICLR 2017 dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_636_1636611_qa_2/task.toml b/tasks/0001_636_1636611_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b6683a94596457daefa45b5b720b43eaf61059ba
--- /dev/null
+++ b/tasks/0001_636_1636611_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_636_1636611_qa_2"
+description = "What is the most commonly assigned review rating in the ICLR 2017 dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/636/1636611.ipynb_qa_2"
+kaggle_dataset_name = "ahmaurya/iclr2017reviews"
+gold_answer = "6: Marginally above acceptance threshold"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ahmaurya__iclr2017reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ahmaurya/iclr2017reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6: Marginally above acceptance threshold"
+QUESTION = "What is the most commonly assigned review rating in the ICLR 2017 dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_656_1656907_qa_2/instruction.md b/tasks/0001_656_1656907_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4ab94248977211d6803877ff7504e3e3d15fe087
--- /dev/null
+++ b/tasks/0001_656_1656907_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- DigiDB_digimonlist.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average (mean) Level 50 Attack value for all Digimon in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_656_1656907_qa_2/task.toml b/tasks/0001_656_1656907_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..13011eb755a45cc274769f4bddf41fefaeed8c89
--- /dev/null
+++ b/tasks/0001_656_1656907_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_656_1656907_qa_2"
+description = "What is the average (mean) Level 50 Attack value for all Digimon in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/656/1656907.ipynb_qa_2"
+kaggle_dataset_name = "rtatman/digidb"
+gold_answer = "124.52"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rtatman__digidb"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rtatman/digidb"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "124.52"
+QUESTION = "What is the average (mean) Level 50 Attack value for all Digimon in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_656_1656907_qa_5/instruction.md b/tasks/0001_656_1656907_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..446165c620fbb5c11fb5729ae450de0c685f0544
--- /dev/null
+++ b/tasks/0001_656_1656907_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- DigiDB_digimonlist.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average number of Equip Slots for all Digimon in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_656_1656907_qa_5/task.toml b/tasks/0001_656_1656907_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ebff1069d67d0746094ccd011ecc4ee623500cf5
--- /dev/null
+++ b/tasks/0001_656_1656907_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_656_1656907_qa_5"
+description = "What is the average number of Equip Slots for all Digimon in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/656/1656907.ipynb_qa_5"
+kaggle_dataset_name = "rtatman/digidb"
+gold_answer = "1.57"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rtatman__digidb"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rtatman/digidb"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.57"
+QUESTION = "What is the average number of Equip Slots for all Digimon in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_667_1667317_qa_1/instruction.md b/tasks/0001_667_1667317_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..97927904adcd0963c64b068027bc937243f9f617
--- /dev/null
+++ b/tasks/0001_667_1667317_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- camera_dataset.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum zoom range (difference between maximum Zoom tele and minimum Zoom wide) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_667_1667317_qa_1/task.toml b/tasks/0001_667_1667317_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a1d38ce13629e60dac89867046ed5be8ba80ff3f
--- /dev/null
+++ b/tasks/0001_667_1667317_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_667_1667317_qa_1"
+description = "What is the maximum zoom range (difference between maximum Zoom tele and minimum Zoom wide) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/667/1667317.ipynb_qa_1"
+kaggle_dataset_name = "crawford/1000-cameras-dataset"
+gold_answer = "518.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "crawford__1000-cameras-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crawford/1000-cameras-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "518.0"
+QUESTION = "What is the maximum zoom range (difference between maximum Zoom tele and minimum Zoom wide) in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_674_1674081_qa_1/instruction.md b/tasks/0001_674_1674081_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a0e9d44f8f6f3b8800dbc895dd9c3f6e3ca499f3
--- /dev/null
+++ b/tasks/0001_674_1674081_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- carInsurance_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum value in the 'Balance' field before outlier removal in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_674_1674081_qa_1/task.toml b/tasks/0001_674_1674081_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..82128dc8ffd71f6224b3a100112c2f97e87b8a81
--- /dev/null
+++ b/tasks/0001_674_1674081_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_674_1674081_qa_1"
+description = "What is the maximum value in the 'Balance' field before outlier removal in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/674/1674081.ipynb_qa_1"
+kaggle_dataset_name = "kondla/carinsurance"
+gold_answer = "98417"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kondla__carinsurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kondla/carinsurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "98417"
+QUESTION = "What is the maximum value in the 'Balance' field before outlier removal in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_736_1736876_qa_4/instruction.md b/tasks/0001_736_1736876_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..30e96cb4dc86d0401fd3905d99d86c037be98b39
--- /dev/null
+++ b/tasks/0001_736_1736876_qa_4/instruction.md
@@ -0,0 +1,18 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- multipleChoiceResponses.csv
+- conversionRates.csv
+- schema.csv
+- freeformResponses.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many numeric columns are present in the dataset before additional processing?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_736_1736876_qa_4/task.toml b/tasks/0001_736_1736876_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..233ea627fec0e11377e7e89a962b615f870da552
--- /dev/null
+++ b/tasks/0001_736_1736876_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_736_1736876_qa_4"
+description = "How many numeric columns are present in the dataset before additional processing?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/736/1736876.ipynb_qa_4"
+kaggle_dataset_name = "kaggle/kaggle-survey-2017"
+gold_answer = "13"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kaggle__kaggle-survey-2017"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kaggle/kaggle-survey-2017"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "13"
+QUESTION = "How many numeric columns are present in the dataset before additional processing?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_737_1737901_qa_1/instruction.md b/tasks/0001_737_1737901_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fdeec4372312ba1e3de89d7c4b15db448bc3a345
--- /dev/null
+++ b/tasks/0001_737_1737901_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- multipleChoiceResponses.csv
+- freeformResponses.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median age of respondents in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_737_1737901_qa_1/task.toml b/tasks/0001_737_1737901_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2e1812ec13cfa283248e7b4a7ec76de58877e907
--- /dev/null
+++ b/tasks/0001_737_1737901_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_737_1737901_qa_1"
+description = "What is the median age of respondents in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/737/1737901.ipynb_qa_1"
+kaggle_dataset_name = "kaggle/kaggle-survey-2017"
+gold_answer = "30"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kaggle__kaggle-survey-2017"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kaggle/kaggle-survey-2017"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "30"
+QUESTION = "What is the median age of respondents in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_741_1741634_qa_2/instruction.md b/tasks/0001_741_1741634_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..89e63cf69b8f1ba58d26878741202cea83a607f3
--- /dev/null
+++ b/tasks/0001_741_1741634_qa_2/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- multipleChoiceResponses.csv
+- conversionRates.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After excluding compensation outliers (values below $1 or above $2,000,000), what is the maximum compensation value retained in the dataset for analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_741_1741634_qa_2/task.toml b/tasks/0001_741_1741634_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..605f1c0c6c94b4fe33572f88e797d2242512430d
--- /dev/null
+++ b/tasks/0001_741_1741634_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_741_1741634_qa_2"
+description = "After excluding compensation outliers (values below $1 or above $2,000,000), what is the maximum compensation value retained in the dataset for analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/741/1741634.ipynb_qa_2"
+kaggle_dataset_name = "kaggle/kaggle-survey-2017"
+gold_answer = "2000000"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kaggle__kaggle-survey-2017"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kaggle/kaggle-survey-2017"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2000000"
+QUESTION = "After excluding compensation outliers (values below $1 or above $2,000,000), what is the maximum compensation value retained in the dataset for analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_761_1761668_qa_2/instruction.md b/tasks/0001_761_1761668_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2593f53ba915f42f2457c5d110daf53a519896d3
--- /dev/null
+++ b/tasks/0001_761_1761668_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data_set_ALL_AML_independent.csv
+- data_set_ALL_AML_train.csv
+- actual.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many columns containing the term "call" were removed from the training dataset during preprocessing?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_761_1761668_qa_2/task.toml b/tasks/0001_761_1761668_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4028013d00d40b863402a8ac6c3e19c1b3bff339
--- /dev/null
+++ b/tasks/0001_761_1761668_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_761_1761668_qa_2"
+description = "How many columns containing the term \"call\" were removed from the training dataset during preprocessing?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/761/1761668.ipynb_qa_2"
+kaggle_dataset_name = "crawford/gene-expression"
+gold_answer = "38"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "crawford__gene-expression"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crawford/gene-expression"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "38"
+QUESTION = "How many columns containing the term \"call\" were removed from the training dataset during preprocessing?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_761_1761668_qa_3/instruction.md b/tasks/0001_761_1761668_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9a1a771634e99291dffd12a4023eaa900c3aef06
--- /dev/null
+++ b/tasks/0001_761_1761668_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median value of the gene expression for the gene 'X64594_at' in the training dataset's sample subset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_761_1761668_qa_3/task.toml b/tasks/0001_761_1761668_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..aa09aa44667bded8e6d136269993bc1ee2357bd9
--- /dev/null
+++ b/tasks/0001_761_1761668_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0001_761_1761668_qa_3"
+description = "What is the median value of the gene expression for the gene 'X64594_at' in the training dataset's sample subset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/761/1761668.ipynb_qa_3"
+kaggle_dataset_name = "crawford/gene-expression"
+gold_answer = "-134.0"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "crawford__gene-expression"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crawford/gene-expression"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-134.0"
+QUESTION = "What is the median value of the gene expression for the gene 'X64594_at' in the training dataset's sample subset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_869_1869604_qa_2/instruction.md b/tasks/0001_869_1869604_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d949fe343e4ab22db42d255426df00267e27c041
--- /dev/null
+++ b/tasks/0001_869_1869604_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- creditcard.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average transaction amount across all records in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_869_1869604_qa_2/task.toml b/tasks/0001_869_1869604_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2dc69e73d29065190a393403da5adc6421f44407
--- /dev/null
+++ b/tasks/0001_869_1869604_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_869_1869604_qa_2"
+description = "What is the average transaction amount across all records in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/869/1869604.ipynb_qa_2"
+kaggle_dataset_name = "mlg-ulb/creditcardfraud"
+gold_answer = "88.35"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mlg-ulb__creditcardfraud"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mlg-ulb/creditcardfraud"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "88.35"
+QUESTION = "What is the average transaction amount across all records in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_894_1894014_qa_2/instruction.md b/tasks/0001_894_1894014_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ee053fe98755c93f088c8d16c99c9212c02f1e00
--- /dev/null
+++ b/tasks/0001_894_1894014_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- museums.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean revenue for zoo-type museums after removing duplicate and null records?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_894_1894014_qa_2/task.toml b/tasks/0001_894_1894014_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1ecbd8c0098052a74b65438808578d3511742b28
--- /dev/null
+++ b/tasks/0001_894_1894014_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_894_1894014_qa_2"
+description = "What is the mean revenue for zoo-type museums after removing duplicate and null records?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/894/1894014.ipynb_qa_2"
+kaggle_dataset_name = "imls/museum-directory"
+gold_answer = "5483602"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "imls__museum-directory"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "imls/museum-directory"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5483602"
+QUESTION = "What is the mean revenue for zoo-type museums after removing duplicate and null records?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_938_1938182_qa_3/instruction.md b/tasks/0001_938_1938182_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9a12daa971e18473d56bd454d8920db677f4a6cf
--- /dev/null
+++ b/tasks/0001_938_1938182_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- anonymous-survey-responses.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common interest in data science among participants with a whole lot of programming experience?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_938_1938182_qa_3/task.toml b/tasks/0001_938_1938182_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cb3f2a99d22e8d625e943703698b7dc3ea4d7b18
--- /dev/null
+++ b/tasks/0001_938_1938182_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_938_1938182_qa_3"
+description = "What is the most common interest in data science among participants with a whole lot of programming experience?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/938/1938182.ipynb_qa_3"
+kaggle_dataset_name = "rtatman/5day-data-challenge-signup-survey-responses"
+gold_answer = "I want to get a job where I use data science"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rtatman__5day-data-challenge-signup-survey-responses"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rtatman/5day-data-challenge-signup-survey-responses"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "I want to get a job where I use data science"
+QUESTION = "What is the most common interest in data science among participants with a whole lot of programming experience?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_938_1938182_qa_5/instruction.md b/tasks/0001_938_1938182_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0606e7017d4f85eaeaada41dfd48ac35661a6600
--- /dev/null
+++ b/tasks/0001_938_1938182_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- anonymous-survey-responses.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common pet preference in the overall dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_938_1938182_qa_5/task.toml b/tasks/0001_938_1938182_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5728a2ec5e4945274a37b6b7634b04e41865e44b
--- /dev/null
+++ b/tasks/0001_938_1938182_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_938_1938182_qa_5"
+description = "What is the most common pet preference in the overall dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/938/1938182.ipynb_qa_5"
+kaggle_dataset_name = "rtatman/5day-data-challenge-signup-survey-responses"
+gold_answer = "Dogs"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rtatman__5day-data-challenge-signup-survey-responses"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rtatman/5day-data-challenge-signup-survey-responses"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Dogs"
+QUESTION = "What is the most common pet preference in the overall dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_955_1955907_qa_3/instruction.md b/tasks/0001_955_1955907_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..86907fc9a64f7c45958c3d37830e7d2d0a2eb2a8
--- /dev/null
+++ b/tasks/0001_955_1955907_qa_3/instruction.md
@@ -0,0 +1,18 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- tmdb_5000_credits.csv
+- tmdb_5000_movies.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What are the earliest and latest release years of movies in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <earliest_year>, <latest_year> (comma-separated, plain numbers).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_955_1955907_qa_3/task.toml b/tasks/0001_955_1955907_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ebbf4559d0008b95e82b530d4ab88c36e9fa2a4d
--- /dev/null
+++ b/tasks/0001_955_1955907_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_955_1955907_qa_3"
+description = "What are the earliest and latest release years of movies in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/955/1955907.ipynb_qa_3"
+kaggle_dataset_name = "tmdb/tmdb-movie-metadata"
+gold_answer = "1916, 2017"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "tmdb__tmdb-movie-metadata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1916, 2017"
+QUESTION = "What are the earliest and latest release years of movies in the dataset?"
+REWARD_MODE = "list_csv"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_955_1955907_qa_5/instruction.md b/tasks/0001_955_1955907_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e10d11322e27690fbbc22fb132db7ffb9d144cda
--- /dev/null
+++ b/tasks/0001_955_1955907_qa_5/instruction.md
@@ -0,0 +1,18 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- tmdb_5000_credits.csv
+- tmdb_5000_movies.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What are the four most frequent movie genres in the dataset, accounting for more than half of all genre representations?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the exact genre names.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_955_1955907_qa_5/task.toml b/tasks/0001_955_1955907_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..df8eaa866babd9d73fa8b3da2f21e18791a95925
--- /dev/null
+++ b/tasks/0001_955_1955907_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_955_1955907_qa_5"
+description = "What are the four most frequent movie genres in the dataset, accounting for more than half of all genre representations?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/955/1955907.ipynb_qa_5"
+kaggle_dataset_name = "tmdb/tmdb-movie-metadata"
+gold_answer = "Drama, Comedy, Thriller, Action"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "tmdb__tmdb-movie-metadata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Drama, Comedy, Thriller, Action"
+QUESTION = "What are the four most frequent movie genres in the dataset, accounting for more than half of all genre representations?"
+REWARD_MODE = "list_csv"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_975_1975169_qa_3/instruction.md b/tasks/0001_975_1975169_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..987804f19c3a7fc23835c26e5e9be0be929474d1
--- /dev/null
+++ b/tasks/0001_975_1975169_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which job level has the highest attrition rate based on the boxplot analysis of attrition factors?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_975_1975169_qa_3/task.toml b/tasks/0001_975_1975169_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..92c70427b395b1a45a52820a73b93a0d39438701
--- /dev/null
+++ b/tasks/0001_975_1975169_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_975_1975169_qa_3"
+description = "Which job level has the highest attrition rate based on the boxplot analysis of attrition factors?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/975/1975169.ipynb_qa_3"
+kaggle_dataset_name = "shuchirb/ibm-attrition-analysis"
+gold_answer = "1"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "shuchirb__ibm-attrition-analysis"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "shuchirb/ibm-attrition-analysis"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1"
+QUESTION = "Which job level has the highest attrition rate based on the boxplot analysis of attrition factors?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_998_1998202_qa_2/instruction.md b/tasks/0001_998_1998202_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0cb2b90342fb89d38d71d1694573898436b4a54b
--- /dev/null
+++ b/tasks/0001_998_1998202_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- online_sex_work.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the total number of entries in the Points_Rank column that originally contained the value 'a' before replacement with 0?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_998_1998202_qa_2/task.toml b/tasks/0001_998_1998202_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..db54c06bdf90a9fa0898e1d3c931279a8fdaa553
--- /dev/null
+++ b/tasks/0001_998_1998202_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_998_1998202_qa_2"
+description = "What was the total number of entries in the Points_Rank column that originally contained the value 'a' before replacement with 0?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/998/1998202.ipynb_qa_2"
+kaggle_dataset_name = "panoskostakos/online-sex-work"
+gold_answer = "209"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "panoskostakos__online-sex-work"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "panoskostakos/online-sex-work"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "209"
+QUESTION = "What was the total number of entries in the Points_Rank column that originally contained the value 'a' before replacement with 0?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0002_084_2084371_qa_5/instruction.md b/tasks/0002_084_2084371_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6adb5499a8b6c80c9fcbf133702609da308c2c79
--- /dev/null
+++ b/tasks/0002_084_2084371_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What are the mean values of fixed acidity and volatile acidity for the "good wine" class (class 0) in the preprocessed dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the two mean values, in the order fixed acidity then volatile acidity, as plain numbers.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0002_084_2084371_qa_5/task.toml b/tasks/0002_084_2084371_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..92556fcadff196c0a03cd38dcefd921bb9f924f3
--- /dev/null
+++ b/tasks/0002_084_2084371_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0002_084_2084371_qa_5"
+description = "What are the mean values of fixed acidity and volatile acidity for the \"good wine\" class (class 0) in the preprocessed dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0002/084/2084371.ipynb_qa_5"
+kaggle_dataset_name = "mlshff/red-wine-quality-wihout-first-line"
+gold_answer = "8.735795454545455, 0.40863636363636363"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mlshff__red-wine-quality-wihout-first-line"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mlshff/red-wine-quality-wihout-first-line"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "8.735795454545455, 0.40863636363636363"
+QUESTION = "What are the mean values of fixed acidity and volatile acidity for the \"good wine\" class (class 0) in the preprocessed dataset?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0002_133_2133400_qa_2/instruction.md b/tasks/0002_133_2133400_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b05794fad0891c3e0b09fba44f0dc3bd2ebcab35
--- /dev/null
+++ b/tasks/0002_133_2133400_qa_2/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- events.csv
+- ginf.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the standard deviation of goals scored by the winning team across all matches in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0002_133_2133400_qa_2/task.toml b/tasks/0002_133_2133400_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9a26f0dda87309b5cb13696d2d6d48ea4a297b73
--- /dev/null
+++ b/tasks/0002_133_2133400_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0002_133_2133400_qa_2"
+description = "What is the standard deviation of goals scored by the winning team across all matches in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0002/133/2133400.ipynb_qa_2"
+kaggle_dataset_name = "secareanualin/football-events"
+gold_answer = "1.170"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "secareanualin__football-events"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "secareanualin/football-events"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.170"
+QUESTION = "What is the standard deviation of goals scored by the winning team across all matches in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0002_203_2203836_qa_5/instruction.md b/tasks/0002_203_2203836_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca2a478e113065bd9729b77e2a410ee255409309
--- /dev/null
+++ b/tasks/0002_203_2203836_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many SMS messages in the dataset contain angle bracket symbols ("<" or ">") and are classified as spam (class 1)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0002_203_2203836_qa_5/task.toml b/tasks/0002_203_2203836_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e341d8874034fd6e53f2226d8b09c85c1a85ab0a
--- /dev/null
+++ b/tasks/0002_203_2203836_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0002_203_2203836_qa_5"
+description = "How many SMS messages in the dataset contain angle bracket symbols (\"<\" or \">\") and are classified as spam (class 1)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0002/203/2203836.ipynb_qa_5"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "19"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "19"
+QUESTION = "How many SMS messages in the dataset contain angle bracket symbols (\"<\" or \">\") and are classified as spam (class 1)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0002_349_2349296_qa_3/instruction.md b/tasks/0002_349_2349296_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..75549d3c9f93905d27456058f77aff94e3579424
--- /dev/null
+++ b/tasks/0002_349_2349296_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winemag-data-130k-v2.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest score (points) assigned to any wine in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0002_349_2349296_qa_3/task.toml b/tasks/0002_349_2349296_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7fd627cdb6035173ff388805e8c3b98854338536
--- /dev/null
+++ b/tasks/0002_349_2349296_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0002_349_2349296_qa_3"
+description = "What is the highest score (points) assigned to any wine in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0002/349/2349296.ipynb_qa_3"
+kaggle_dataset_name = "zynicide/wine-reviews"
+gold_answer = "100"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "zynicide__wine-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zynicide/wine-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "100"
+QUESTION = "What is the highest score (points) assigned to any wine in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0010_506_10506952_qa_4/instruction.md b/tasks/0010_506_10506952_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6e3dd9bfa307a47dfc02607f450aec3091fd3052
--- /dev/null
+++ b/tasks/0010_506_10506952_qa_4/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature combination provides the best visual separation of species according to the scatter plot analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the exact column names.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0010_506_10506952_qa_4/task.toml b/tasks/0010_506_10506952_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..354a9b544feed3754f0a9b162703818087ad8445
--- /dev/null
+++ b/tasks/0010_506_10506952_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0010_506_10506952_qa_4"
+description = "Which feature combination provides the best visual separation of species according to the scatter plot analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0010/506/10506952.ipynb_qa_4"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "PetalLengthCm, PetalWidthCm"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "PetalLengthCm, PetalWidthCm"
+QUESTION = "Which feature combination provides the best visual separation of species according to the scatter plot analysis?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0010_515_10515511_qa_1/instruction.md b/tasks/0010_515_10515511_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5d4504cb5a8493798a4dda7745954ba8c4ab0d87
--- /dev/null
+++ b/tasks/0010_515_10515511_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- hotel-reviews.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which web browser was most frequently used by guests when submitting hotel reviews?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0010_515_10515511_qa_1/task.toml b/tasks/0010_515_10515511_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fe42423b4e5d98b5587f3e77f69bf690046d5372
--- /dev/null
+++ b/tasks/0010_515_10515511_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0010_515_10515511_qa_1"
+description = "Which web browser was most frequently used by guests when submitting hotel reviews?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0010/515/10515511.ipynb_qa_1"
+kaggle_dataset_name = "harmanpreet93/hotelreviews"
+gold_answer = "Firefox"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "harmanpreet93__hotelreviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "harmanpreet93/hotelreviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Firefox"
+QUESTION = "Which web browser was most frequently used by guests when submitting hotel reviews?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0010_631_10631903_qa_1/instruction.md b/tasks/0010_631_10631903_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0b7a8d7b4d2222447e59d93cd0e106fed868b65e
--- /dev/null
+++ b/tasks/0010_631_10631903_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- 2017.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which country has the highest Happiness Score in the 2017 dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0010_631_10631903_qa_1/task.toml b/tasks/0010_631_10631903_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7fabe00a8bac07154284cc5e6e0b30ce4edd5ad7
--- /dev/null
+++ b/tasks/0010_631_10631903_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0010_631_10631903_qa_1"
+description = "Which country has the highest Happiness Score in the 2017 dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0010/631/10631903.ipynb_qa_1"
+kaggle_dataset_name = "unsdsn/world-happiness"
+gold_answer = "Norway"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "unsdsn__world-happiness"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "unsdsn/world-happiness"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Norway"
+QUESTION = "Which country has the highest Happiness Score in the 2017 dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0011_088_11088784_qa_2/instruction.md b/tasks/0011_088_11088784_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..96cd5e8c92326cd3963dcadb6fb69d0181adf076
--- /dev/null
+++ b/tasks/0011_088_11088784_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winemag-data-130k-v2.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common wine variety among top-rated (≥90 points) Australian wines in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0011_088_11088784_qa_2/task.toml b/tasks/0011_088_11088784_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1ca38cc51070eb6feaab27a3fae6ef4431b8ace5
--- /dev/null
+++ b/tasks/0011_088_11088784_qa_2/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0011_088_11088784_qa_2"
+description = "What is the most common wine variety among top-rated (≥90 points) Australian wines in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0011/088/11088784.ipynb_qa_2"
+kaggle_dataset_name = "zynicide/wine-reviews"
+gold_answer = "Shiraz"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "zynicide__wine-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zynicide/wine-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Shiraz"
+QUESTION = "What is the most common wine variety among top-rated (≥90 points) Australian wines in the dataset?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0011_224_11224334_qa_1/instruction.md b/tasks/0011_224_11224334_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a513bb792ea3ce182dd9e5eece639bcba9308656
--- /dev/null
+++ b/tasks/0011_224_11224334_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which generation contains the highest number of Pokémon species in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0011_224_11224334_qa_1/task.toml b/tasks/0011_224_11224334_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c3d68ece097326848a27d2f81f9f73697d62f1c6
--- /dev/null
+++ b/tasks/0011_224_11224334_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0011_224_11224334_qa_1"
+description = "Which generation contains the highest number of Pokémon species in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0011/224/11224334.ipynb_qa_1"
+kaggle_dataset_name = "abcsds/pokemon"
+gold_answer = "1"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abcsds__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abcsds/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1"
+QUESTION = "Which generation contains the highest number of Pokémon species in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0011_637_11637182_qa_3/instruction.md b/tasks/0011_637_11637182_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d589915e9432c1528d2813aa38df66087bc86867
--- /dev/null
+++ b/tasks/0011_637_11637182_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference in the number of patients between the non-diabetic (Outcome = 0) group and the diabetic (Outcome = 1) group?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0011_637_11637182_qa_3/task.toml b/tasks/0011_637_11637182_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3280d63427a0c68e7ddfac84b507e18a21da96bd
--- /dev/null
+++ b/tasks/0011_637_11637182_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0011_637_11637182_qa_3"
+description = "What is the difference in the number of patients between the non-diabetic (Outcome = 0) group and the diabetic (Outcome = 1) group?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0011/637/11637182.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "232"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "232"
+QUESTION = "What is the difference in the number of patients between the non-diabetic (Outcome = 0) group and the diabetic (Outcome = 1) group?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0012_222_12222108_qa_2/instruction.md b/tasks/0012_222_12222108_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..24825052ea89021a1f86a482a8201131ee3c4457
--- /dev/null
+++ b/tasks/0012_222_12222108_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- column_2C_weka.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the R² score of the linear regression model predicting sacral slope from pelvic incidence in abnormal patients?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0012_222_12222108_qa_2/task.toml b/tasks/0012_222_12222108_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4b6cb2d47827232ab5812b6295b13247f0a5147c
--- /dev/null
+++ b/tasks/0012_222_12222108_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0012_222_12222108_qa_2"
+description = "What is the R² score of the linear regression model predicting sacral slope from pelvic incidence in abnormal patients?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0012/222/12222108.ipynb_qa_2"
+kaggle_dataset_name = "uciml/biomechanical-features-of-orthopedic-patients"
+gold_answer = "0.6458"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__biomechanical-features-of-orthopedic-patients"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/biomechanical-features-of-orthopedic-patients"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.6458"
+QUESTION = "What is the R² score of the linear regression model predicting sacral slope from pelvic incidence in abnormal patients?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0012_748_12748314_qa_3/instruction.md b/tasks/0012_748_12748314_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c3959f93a593a8632ebb44a6461e7b7d3a9be3fc
--- /dev/null
+++ b/tasks/0012_748_12748314_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- haberman.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum axil_nodes count observed for a survived patient versus a not-survived patient?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as comma-separated <label>=<value> pairs, label first, with the exact labels "survived" and "<label1>".
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0012_748_12748314_qa_3/task.toml b/tasks/0012_748_12748314_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..054b0f703f119e9be8e035a6a85790c01d15e95c
--- /dev/null
+++ b/tasks/0012_748_12748314_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0012_748_12748314_qa_3"
+description = "What is the maximum axil_nodes count observed for a survived patient versus a not-survived patient?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0012/748/12748314.ipynb_qa_3"
+kaggle_dataset_name = "gilsousa/habermans-survival-data-set"
+gold_answer = "survived=46, not_survived=52"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gilsousa__habermans-survival-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "survived=46, not_survived=52"
+QUESTION = "What is the maximum axil_nodes count observed for a survived patient versus a not-survived patient?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0012_748_12748314_qa_4/instruction.md b/tasks/0012_748_12748314_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa61d200517882f0d355ee4d7e8e140a510107b4
--- /dev/null
+++ b/tasks/0012_748_12748314_qa_4/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- haberman.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the age threshold below which 75% of survived patients fall, compared to the 75% age threshold for not-survived patients?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of two numbers, in the order: survived threshold, not-survived threshold.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0012_748_12748314_qa_4/task.toml b/tasks/0012_748_12748314_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..63015e1d453b4f1cb18c8e1215b4b9efdf656a2a
--- /dev/null
+++ b/tasks/0012_748_12748314_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0012_748_12748314_qa_4"
+description = "What is the age threshold below which 75% of survived patients fall, compared to the 75% age threshold for not-survived patients?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0012/748/12748314.ipynb_qa_4"
+kaggle_dataset_name = "gilsousa/habermans-survival-data-set"
+gold_answer = "60, 62"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gilsousa__habermans-survival-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "60, 62"
+QUESTION = "What is the age threshold below which 75% of survived patients fall, compared to the 75% age threshold for not-survived patients?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0014_351_14351012_qa_2/instruction.md b/tasks/0014_351_14351012_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..994a0bedd4c4bf939d2bdfc1049d0e9889c792c3
--- /dev/null
+++ b/tasks/0014_351_14351012_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- daily_weather.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the threshold value used to classify days as "high humidity" based on the relative humidity measurement at 3pm?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0014_351_14351012_qa_2/task.toml b/tasks/0014_351_14351012_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0a7199f133a7b47fd6e2ec0b20ff9c2918946830
--- /dev/null
+++ b/tasks/0014_351_14351012_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0014_351_14351012_qa_2"
+description = "What was the threshold value used to classify days as \"high humidity\" based on the relative humidity measurement at 3pm?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0014/351/14351012.ipynb_qa_2"
+kaggle_dataset_name = "ashukr/weatherdata"
+gold_answer = "24.99"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ashukr__weatherdata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ashukr/weatherdata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "24.99"
+QUESTION = "What was the threshold value used to classify days as \"high humidity\" based on the relative humidity measurement at 3pm?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0014_351_14351012_qa_5/instruction.md b/tasks/0014_351_14351012_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e9724196fbd96eae000a92743d90d66f731d1e05
--- /dev/null
+++ b/tasks/0014_351_14351012_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- daily_weather.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the proportion of high humidity days in the training set as indicated by the "high_humidity_label"?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0014_351_14351012_qa_5/task.toml b/tasks/0014_351_14351012_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3a9f1e3ea1bf1bf588b53d87ee3c02e045726404
--- /dev/null
+++ b/tasks/0014_351_14351012_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0014_351_14351012_qa_5"
+description = "What is the proportion of high humidity days in the training set as indicated by the \"high_humidity_label\"?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0014/351/14351012.ipynb_qa_5"
+kaggle_dataset_name = "ashukr/weatherdata"
+gold_answer = "0.494"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ashukr__weatherdata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ashukr/weatherdata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.494"
+QUESTION = "What is the proportion of high humidity days in the training set as indicated by the \"high_humidity_label\"?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0014_367_14367970_qa_1/instruction.md b/tasks/0014_367_14367970_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c784a1b996ad37d2dacbca2fc430656780bad29b
--- /dev/null
+++ b/tasks/0014_367_14367970_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- KaggleV2-May-2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of patients did not show up for their appointments in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0014_367_14367970_qa_1/task.toml b/tasks/0014_367_14367970_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..26265548437becb650f79412a4f3eb3091db1011
--- /dev/null
+++ b/tasks/0014_367_14367970_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0014_367_14367970_qa_1"
+description = "What percentage of patients did not show up for their appointments in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0014/367/14367970.ipynb_qa_1"
+kaggle_dataset_name = "joniarroba/noshowappointments"
+gold_answer = "20.19"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "joniarroba__noshowappointments"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "joniarroba/noshowappointments"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "20.19"
+QUESTION = "What percentage of patients did not show up for their appointments in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0014_428_14428721_qa_5/instruction.md b/tasks/0014_428_14428721_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bfd454c6a2ec89138c0a2f4d4e0bab5b748c3d2a
--- /dev/null
+++ b/tasks/0014_428_14428721_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which Pokémon generation has the highest proportion of legendary Pokémon?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0014_428_14428721_qa_5/task.toml b/tasks/0014_428_14428721_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..37622be3ab352b6e4d8c74ae07c3e8046cdf33ea
--- /dev/null
+++ b/tasks/0014_428_14428721_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0014_428_14428721_qa_5"
+description = "Which Pokémon generation has the highest proportion of legendary Pokémon?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0014/428/14428721.ipynb_qa_5"
+kaggle_dataset_name = "abcsds/pokemon"
+gold_answer = "3"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abcsds__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abcsds/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3"
+QUESTION = "Which Pokémon generation has the highest proportion of legendary Pokémon?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0014_432_14432687_qa_3/instruction.md b/tasks/0014_432_14432687_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e0b47292d23df556bf8c586037983a378fd732d0
--- /dev/null
+++ b/tasks/0014_432_14432687_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the standard deviation of the Petal Length feature before standardization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0014_432_14432687_qa_3/task.toml b/tasks/0014_432_14432687_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e2251ce6b20efef0e60413371aac2d42da928283
--- /dev/null
+++ b/tasks/0014_432_14432687_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0014_432_14432687_qa_3"
+description = "What is the standard deviation of the Petal Length feature before standardization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0014/432/14432687.ipynb_qa_3"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "1.764"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.764"
+QUESTION = "What is the standard deviation of the Petal Length feature before standardization?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0014_613_14613843_qa_4/instruction.md b/tasks/0014_613_14613843_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2dfa05a99d8d12bcbe24067c2cfd85ac2ed601c0
--- /dev/null
+++ b/tasks/0014_613_14613843_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many distinct audio features are used as input variables in the decision tree and random forest models?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0014_613_14613843_qa_4/task.toml b/tasks/0014_613_14613843_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7419b196c131d1f11e04dcefe210a796e9967cc4
--- /dev/null
+++ b/tasks/0014_613_14613843_qa_4/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0014_613_14613843_qa_4"
+description = "How many distinct audio features are used as input variables in the decision tree and random forest models?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0014/613/14613843.ipynb_qa_4"
+kaggle_dataset_name = "geomack/spotifyclassification"
+gold_answer = "13"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "geomack__spotifyclassification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "geomack/spotifyclassification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "13"
+QUESTION = "How many distinct audio features are used as input variables in the decision tree and random forest models?"
+REWARD_MODE = "numeric"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0015_285_15285404_qa_3/instruction.md b/tasks/0015_285_15285404_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d098ef1a0354c2b18869bc60c165db8b4614389a
--- /dev/null
+++ b/tasks/0015_285_15285404_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- bigml_59c28831336c6604c800002a.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average account length of customers in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0015_285_15285404_qa_3/task.toml b/tasks/0015_285_15285404_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..249b7f217cf2f1cd53132a1e948a0b52803e7662
--- /dev/null
+++ b/tasks/0015_285_15285404_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0015_285_15285404_qa_3"
+description = "What is the average account length of customers in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0015/285/15285404.ipynb_qa_3"
+kaggle_dataset_name = "becksddf/churn-in-telecoms-dataset"
+gold_answer = "101.06"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "becksddf__churn-in-telecoms-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "becksddf/churn-in-telecoms-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "101.06"
+QUESTION = "What is the average account length of customers in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0015_404_15404226_qa_1/instruction.md b/tasks/0015_404_15404226_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f5306e75c8afa062597375da29604a9f32367813
--- /dev/null
+++ b/tasks/0015_404_15404226_qa_1/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Salaries.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which year between 2011-2014 had the highest average BasePay, and what was the average value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <year>, <value> (comma-separated, year first, keep two decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0015_404_15404226_qa_1/task.toml b/tasks/0015_404_15404226_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c03e43916aa85a298db36202c29994fb6d0c6509
--- /dev/null
+++ b/tasks/0015_404_15404226_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0015_404_15404226_qa_1"
+description = "Which year between 2011-2014 had the highest average BasePay, and what was the average value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0015/404/15404226.ipynb_qa_1"
+kaggle_dataset_name = "kaggle/sf-salaries"
+gold_answer = "2013, 69630.03"
+reward_mode_initial = "list"
+package_tier = 0
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kaggle__sf-salaries"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kaggle/sf-salaries"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2013, 69630.03"
+QUESTION = "Which year between 2011-2014 had the highest average BasePay, and what was the average value?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0015_624_15624986_qa_4/instruction.md b/tasks/0015_624_15624986_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3f65764e3afbc0eca4eea1bce4d9cd874eb1c787
--- /dev/null
+++ b/tasks/0015_624_15624986_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average sepal length across all 150 samples in the Iris dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0015_624_15624986_qa_4/task.toml b/tasks/0015_624_15624986_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..99b4bfc8eb2707a79de11a1997138b558e9938aa
--- /dev/null
+++ b/tasks/0015_624_15624986_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0015_624_15624986_qa_4"
+description = "What is the average sepal length across all 150 samples in the Iris dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0015/624/15624986.ipynb_qa_4"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "5.84"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5.84"
+QUESTION = "What is the average sepal length across all 150 samples in the Iris dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0016_573_16573161_qa_2/instruction.md b/tasks/0016_573_16573161_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9b896135e87ceba58b2d3832f07a23dfc03b6009
--- /dev/null
+++ b/tasks/0016_573_16573161_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the proportion of legendary Pokémon among the Flying primary type?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0016_573_16573161_qa_2/task.toml b/tasks/0016_573_16573161_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3176c84046cc8ce9205a5afec9413ca4f9f9ba27
--- /dev/null
+++ b/tasks/0016_573_16573161_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0016_573_16573161_qa_2"
+description = "What is the proportion of legendary Pokémon among the Flying primary type?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0016/573/16573161.ipynb_qa_2"
+kaggle_dataset_name = "rounakbanik/pokemon"
+gold_answer = "1/3"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rounakbanik__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rounakbanik/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1/3"
+QUESTION = "What is the proportion of legendary Pokémon among the Flying primary type?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0016_945_16945752_qa_1/instruction.md b/tasks/0016_945_16945752_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8e289b1e390ea57c12b3f31bbe374e3875ffdf1
--- /dev/null
+++ b/tasks/0016_945_16945752_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- haberman.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean axillary node count difference between patients who survived more than 5 years and those who did not?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0016_945_16945752_qa_1/task.toml b/tasks/0016_945_16945752_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ca085741f2818f89519ec9beda839dfb5d40af8b
--- /dev/null
+++ b/tasks/0016_945_16945752_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0016_945_16945752_qa_1"
+description = "What is the mean axillary node count difference between patients who survived more than 5 years and those who did not?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0016/945/16945752.ipynb_qa_1"
+kaggle_dataset_name = "gilsousa/habermans-survival-data-set"
+gold_answer = "4.67"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gilsousa__habermans-survival-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4.67"
+QUESTION = "What is the mean axillary node count difference between patients who survived more than 5 years and those who did not?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0016_952_16952441_qa_4/instruction.md b/tasks/0016_952_16952441_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0844343c6a13d7f43537571d6bccc4a5a16ab205
--- /dev/null
+++ b/tasks/0016_952_16952441_qa_4/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- 2015.csv
+- 2016.csv
+- 2017.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many countries in the Middle East and Northern Africa region had a happiness score above 7 in 2015?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0016_952_16952441_qa_4/task.toml b/tasks/0016_952_16952441_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cd3615a769b64aa89a8f92a62fca0a951bc8f864
--- /dev/null
+++ b/tasks/0016_952_16952441_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0016_952_16952441_qa_4"
+description = "How many countries in the Middle East and Northern Africa region had a happiness score above 7 in 2015?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0016/952/16952441.ipynb_qa_4"
+kaggle_dataset_name = "unsdsn/world-happiness"
+gold_answer = "1"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "unsdsn__world-happiness"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "unsdsn/world-happiness"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1"
+QUESTION = "How many countries in the Middle East and Northern Africa region had a happiness score above 7 in 2015?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0017_257_17257933_qa_3/instruction.md b/tasks/0017_257_17257933_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e68023e59d22be86ae71dd1e69ff19881727f92e
--- /dev/null
+++ b/tasks/0017_257_17257933_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the interquartile range (IQR) for the Age feature in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0017_257_17257933_qa_3/task.toml b/tasks/0017_257_17257933_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..413e85d8bfbf48b1617de3b9112b7711cdebc77d
--- /dev/null
+++ b/tasks/0017_257_17257933_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0017_257_17257933_qa_3"
+description = "What is the interquartile range (IQR) for the Age feature in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0017/257/17257933.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "17"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "17"
+QUESTION = "What is the interquartile range (IQR) for the Age feature in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0017_257_17257933_qa_4/instruction.md b/tasks/0017_257_17257933_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..856247e0e9add1a82d4ff6915cd2da1f957d1d7d
--- /dev/null
+++ b/tasks/0017_257_17257933_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many outliers are present in the Insulin column based on the IQR method?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0017_257_17257933_qa_4/task.toml b/tasks/0017_257_17257933_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e75786447cbe446ed42ce85dc4753a8e90fc8828
--- /dev/null
+++ b/tasks/0017_257_17257933_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0017_257_17257933_qa_4"
+description = "How many outliers are present in the Insulin column based on the IQR method?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0017/257/17257933.ipynb_qa_4"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "34"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "34"
+QUESTION = "How many outliers are present in the Insulin column based on the IQR method?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0017_257_17257933_qa_5/instruction.md b/tasks/0017_257_17257933_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..44029eb2feb479c0c7aed35b2574ed274b0f1966
--- /dev/null
+++ b/tasks/0017_257_17257933_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many outliers are present in the Glucose column based on the IQR method?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0017_257_17257933_qa_5/task.toml b/tasks/0017_257_17257933_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3492b5c67350fb713f05c310ae262789946bdc97
--- /dev/null
+++ b/tasks/0017_257_17257933_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0017_257_17257933_qa_5"
+description = "How many outliers are present in the Glucose column based on the IQR method?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0017/257/17257933.ipynb_qa_5"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "5"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5"
+QUESTION = "How many outliers are present in the Glucose column based on the IQR method?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0017_291_17291057_qa_5/instruction.md b/tasks/0017_291_17291057_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..540b04cc054ecc40b0d12b98fc061f7286293fa7
--- /dev/null
+++ b/tasks/0017_291_17291057_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Based on the correlation matrix analysis, which feature has the highest negative correlation with wine quality?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0017_291_17291057_qa_5/task.toml b/tasks/0017_291_17291057_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d38c7eb24498fee62a9ff3397ef0cca6e65872e9
--- /dev/null
+++ b/tasks/0017_291_17291057_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0017_291_17291057_qa_5"
+description = "Based on the correlation matrix analysis, which feature has the highest negative correlation with wine quality?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0017/291/17291057.ipynb_qa_5"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "volatile acidity"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "volatile acidity"
+QUESTION = "Based on the correlation matrix analysis, which feature has the highest negative correlation with wine quality?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0017_810_17810500_qa_2/instruction.md b/tasks/0017_810_17810500_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f78ee53365b874516312f812cec482fdbc20c78
--- /dev/null
+++ b/tasks/0017_810_17810500_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- HR_comma_sep.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the coefficient value for the 'satisfaction_level' variable in the trained logistic regression model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0017_810_17810500_qa_2/task.toml b/tasks/0017_810_17810500_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..86d6956496d0d6f790bccfae7bba9caee57be77b
--- /dev/null
+++ b/tasks/0017_810_17810500_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0017_810_17810500_qa_2"
+description = "What is the coefficient value for the 'satisfaction_level' variable in the trained logistic regression model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0017/810/17810500.ipynb_qa_2"
+kaggle_dataset_name = "jiangzuo/hr-comma-sep"
+gold_answer = "-4.128237323420271"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "jiangzuo__hr-comma-sep"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jiangzuo/hr-comma-sep"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-4.128237323420271"
+QUESTION = "What is the coefficient value for the 'satisfaction_level' variable in the trained logistic regression model?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0018_020_18020173_qa_5/instruction.md b/tasks/0018_020_18020173_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d58b240b6a9289d1c205ce11c9c4eac35106cf7b
--- /dev/null
+++ b/tasks/0018_020_18020173_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Salaries.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which calendar year has the highest number of salary records in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0018_020_18020173_qa_5/task.toml b/tasks/0018_020_18020173_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..43353b673a17cfd72f1fd2eeb4a70c1923fb6390
--- /dev/null
+++ b/tasks/0018_020_18020173_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0018_020_18020173_qa_5"
+description = "Which calendar year has the highest number of salary records in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0018/020/18020173.ipynb_qa_5"
+kaggle_dataset_name = "kaggle/sf-salaries"
+gold_answer = "2014"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kaggle__sf-salaries"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kaggle/sf-salaries"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2014"
+QUESTION = "Which calendar year has the highest number of salary records in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0018_278_18278432_qa_1/instruction.md b/tasks/0018_278_18278432_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..00f083a515e194d0e87d34583f8d40a59fe613a6
--- /dev/null
+++ b/tasks/0018_278_18278432_qa_1/instruction.md
@@ -0,0 +1,18 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- class.csv
+- zoo.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which animal class has the highest number of domesticated species, and how many are there?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <class>, <count> (comma-separated, label first, plain number).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0018_278_18278432_qa_1/task.toml b/tasks/0018_278_18278432_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..61b09c0063a72d713c3a9d4fbe0f2dd5c62eb5e5
--- /dev/null
+++ b/tasks/0018_278_18278432_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0018_278_18278432_qa_1"
+description = "Which animal class has the highest number of domesticated species, and how many are there?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0018/278/18278432.ipynb_qa_1"
+kaggle_dataset_name = "uciml/zoo-animal-classification"
+gold_answer = "Mammal, 8"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__zoo-animal-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/zoo-animal-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Mammal, 8"
+QUESTION = "Which animal class has the highest number of domesticated species, and how many are there?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0018_519_18519406_qa_1/instruction.md b/tasks/0018_519_18519406_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0198c371d66a30ab4b7db0f2828bc8cbf81900f
--- /dev/null
+++ b/tasks/0018_519_18519406_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WNBA Stats.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum number of games played by any player in the 2016-2017 WNBA season according to the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0018_519_18519406_qa_1/task.toml b/tasks/0018_519_18519406_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..797ac12c093397038e88e9f3263567550bc46ded
--- /dev/null
+++ b/tasks/0018_519_18519406_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0018_519_18519406_qa_1"
+description = "What is the maximum number of games played by any player in the 2016-2017 WNBA season according to the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0018/519/18519406.ipynb_qa_1"
+kaggle_dataset_name = "jinxbe/wnba-player-stats-2017"
+gold_answer = "32"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "jinxbe__wnba-player-stats-2017"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jinxbe/wnba-player-stats-2017"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "32"
+QUESTION = "What is the maximum number of games played by any player in the 2016-2017 WNBA season according to the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0019_517_19517366_qa_3/instruction.md b/tasks/0019_517_19517366_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8dffa315a3c170894440bd45e122379a1b51443
--- /dev/null
+++ b/tasks/0019_517_19517366_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the precision score of the Random Forest model on the test dataset after training and prediction?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0019_517_19517366_qa_3/task.toml b/tasks/0019_517_19517366_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7f7e04563b7d2c4e16e312ae19d56ca8ed507c30
--- /dev/null
+++ b/tasks/0019_517_19517366_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0019_517_19517366_qa_3"
+description = "What is the precision score of the Random Forest model on the test dataset after training and prediction?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0019/517/19517366.ipynb_qa_3"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "1.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.0"
+QUESTION = "What is the precision score of the Random Forest model on the test dataset after training and prediction?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0019_787_19787626_qa_3/instruction.md b/tasks/0019_787_19787626_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..93e4429a04afd128cf2017aafb0ce2546232d5ae
--- /dev/null
+++ b/tasks/0019_787_19787626_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- USA_Housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the intercept value of the trained linear regression model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0019_787_19787626_qa_3/task.toml b/tasks/0019_787_19787626_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..efcf8be6aaf2518a8efef8ab34d63f20ec28680d
--- /dev/null
+++ b/tasks/0019_787_19787626_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0019_787_19787626_qa_3"
+description = "What is the intercept value of the trained linear regression model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0019/787/19787626.ipynb_qa_3"
+kaggle_dataset_name = "gopalchettri/usa-housing"
+gold_answer = "-2640159.796851911"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gopalchettri__usa-housing"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gopalchettri/usa-housing"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-2640159.796851911"
+QUESTION = "What is the intercept value of the trained linear regression model?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0019_787_19787626_qa_4/instruction.md b/tasks/0019_787_19787626_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e7f53e59acf3ef0191f9071af187e58eb99ab2c2
--- /dev/null
+++ b/tasks/0019_787_19787626_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- USA_Housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average housing price in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0019_787_19787626_qa_4/task.toml b/tasks/0019_787_19787626_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cb18d02886316b8de24e6e36c3765d35bdd3e669
--- /dev/null
+++ b/tasks/0019_787_19787626_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0019_787_19787626_qa_4"
+description = "What is the average housing price in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0019/787/19787626.ipynb_qa_4"
+kaggle_dataset_name = "gopalchettri/usa-housing"
+gold_answer = "1232073.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gopalchettri__usa-housing"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gopalchettri/usa-housing"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1232073.0"
+QUESTION = "What is the average housing price in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0021_358_21358195_qa_4/instruction.md b/tasks/0021_358_21358195_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cb2df381b90258f4e8a0d5c245afd15084b6591d
--- /dev/null
+++ b/tasks/0021_358_21358195_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum PetalWidthCm observed in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0021_358_21358195_qa_4/task.toml b/tasks/0021_358_21358195_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b7e0870d365cc0c59cc57d87e999d483d2a00f7d
--- /dev/null
+++ b/tasks/0021_358_21358195_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0021_358_21358195_qa_4"
+description = "What is the maximum PetalWidthCm observed in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0021/358/21358195.ipynb_qa_4"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "2.5"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2.5"
+QUESTION = "What is the maximum PetalWidthCm observed in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0021_384_21384330_qa_2/instruction.md b/tasks/0021_384_21384330_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..acc91a518f628fdac6b7ad8822ee0e59d14cb478
--- /dev/null
+++ b/tasks/0021_384_21384330_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Fleet Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which airline has the highest total number of aircraft across all periods?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0021_384_21384330_qa_2/task.toml b/tasks/0021_384_21384330_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1c83ec8a32cb9548b719d261b42f40537e2591f2
--- /dev/null
+++ b/tasks/0021_384_21384330_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0021_384_21384330_qa_2"
+description = "Which airline has the highest total number of aircraft across all periods?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0021/384/21384330.ipynb_qa_2"
+kaggle_dataset_name = "traceyvanp/airlinefleet"
+gold_answer = "American Airlines"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "traceyvanp__airlinefleet"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "traceyvanp/airlinefleet"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "American Airlines"
+QUESTION = "Which airline has the highest total number of aircraft across all periods?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0021_698_21698205_qa_2/instruction.md b/tasks/0021_698_21698205_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8015bd2f479e3f691db76a0ac66a0e38dde45596
--- /dev/null
+++ b/tasks/0021_698_21698205_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature extraction technique achieves 100% accuracy while reducing the number of features from 117 to 1?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0021_698_21698205_qa_2/task.toml b/tasks/0021_698_21698205_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3e8a856336e52a90f9e0541e79914ba4f8b7d7fc
--- /dev/null
+++ b/tasks/0021_698_21698205_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0021_698_21698205_qa_2"
+description = "Which feature extraction technique achieves 100% accuracy while reducing the number of features from 117 to 1?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0021/698/21698205.ipynb_qa_2"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "LDA"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "LDA"
+QUESTION = "Which feature extraction technique achieves 100% accuracy while reducing the number of features from 117 to 1?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0021_699_21699891_qa_1/instruction.md b/tasks/0021_699_21699891_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bf76c5165a97ff7bc44dfd0349a620508f321f1d
--- /dev/null
+++ b/tasks/0021_699_21699891_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- studentDropIndia_20161215.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of students in the dataset dropped out according to the 'continue_drop' classification?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0021_699_21699891_qa_1/task.toml b/tasks/0021_699_21699891_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e4e2f72004ae92a937c6933d0294aa44644efa11
--- /dev/null
+++ b/tasks/0021_699_21699891_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0021_699_21699891_qa_1"
+description = "What percentage of students in the dataset dropped out according to the 'continue_drop' classification?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0021/699/21699891.ipynb_qa_1"
+kaggle_dataset_name = "imrandude/studentdropindia2016"
+gold_answer = "4.7"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "imrandude__studentdropindia2016"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "imrandude/studentdropindia2016"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4.7"
+QUESTION = "What percentage of students in the dataset dropped out according to the 'continue_drop' classification?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0021_804_21804957_qa_3/instruction.md b/tasks/0021_804_21804957_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7f8a70eda1fcb1955a416c9ebf41e4fb79f41a36
--- /dev/null
+++ b/tasks/0021_804_21804957_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Reviews.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common sentiment category in the dataset after deduplication?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0021_804_21804957_qa_3/task.toml b/tasks/0021_804_21804957_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..050ae641300d640ac1b271b86ee95950fd815541
--- /dev/null
+++ b/tasks/0021_804_21804957_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0021_804_21804957_qa_3"
+description = "What is the most common sentiment category in the dataset after deduplication?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0021/804/21804957.ipynb_qa_3"
+kaggle_dataset_name = "snap/amazon-fine-food-reviews"
+gold_answer = "Positive"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "snap__amazon-fine-food-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "snap/amazon-fine-food-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Positive"
+QUESTION = "What is the most common sentiment category in the dataset after deduplication?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0021_893_21893685_qa_5/instruction.md b/tasks/0021_893_21893685_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..81260883d1c36591e3b4116e1fea7d964fdf1929
--- /dev/null
+++ b/tasks/0021_893_21893685_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the proportion of benign (B) vs malignant (M) tumors in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <percentage>% <label2>, <percentage>% <label1> (comma-separated, percentages with one decimal).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0021_893_21893685_qa_5/task.toml b/tasks/0021_893_21893685_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2adba8fd6d2017cdd61ea7e8a3476650b449011d
--- /dev/null
+++ b/tasks/0021_893_21893685_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0021_893_21893685_qa_5"
+description = "What is the proportion of benign (B) vs malignant (M) tumors in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0021/893/21893685.ipynb_qa_5"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "62.7% benign, 37.3% malignant"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "62.7% benign, 37.3% malignant"
+QUESTION = "What is the proportion of benign (B) vs malignant (M) tumors in the dataset?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0022_555_22555686_qa_2/instruction.md b/tasks/0022_555_22555686_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..db53606ae53551421872046896a718bbf1d910af
--- /dev/null
+++ b/tasks/0022_555_22555686_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many features were retained in the dataset after preprocessing steps including removal of non-informative columns and normalization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0022_555_22555686_qa_2/task.toml b/tasks/0022_555_22555686_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..681b507deb181ff2284d3032ad37b2e9ca086322
--- /dev/null
+++ b/tasks/0022_555_22555686_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0022_555_22555686_qa_2"
+description = "How many features were retained in the dataset after preprocessing steps including removal of non-informative columns and normalization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0022/555/22555686.ipynb_qa_2"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "30"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "30"
+QUESTION = "How many features were retained in the dataset after preprocessing steps including removal of non-informative columns and normalization?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0022_609_22609620_qa_3/instruction.md b/tasks/0022_609_22609620_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fc2bf464a7e641004cbe566f5d8a6d7f5b20a558
--- /dev/null
+++ b/tasks/0022_609_22609620_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- AirPassengers.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What p-value was obtained from the Dickey-Fuller test for stationarity of the original time series?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0022_609_22609620_qa_3/task.toml b/tasks/0022_609_22609620_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..02c899e37b4f7438c2bef82038c4804aa33f1ed8
--- /dev/null
+++ b/tasks/0022_609_22609620_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0022_609_22609620_qa_3"
+description = "What p-value was obtained from the Dickey-Fuller test for stationarity of the original time series?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0022/609/22609620.ipynb_qa_3"
+kaggle_dataset_name = "rakannimer/air-passengers"
+gold_answer = "0.991880"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rakannimer__air-passengers"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rakannimer/air-passengers"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.991880"
+QUESTION = "What p-value was obtained from the Dickey-Fuller test for stationarity of the original time series?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0022_790_22790047_qa_2/instruction.md b/tasks/0022_790_22790047_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..552b6ab0ce2d79e6d69ab076ba373114f540da3d
--- /dev/null
+++ b/tasks/0022_790_22790047_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Family Income and Expenditure.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest household income recorded in the dataset after removing missing values in the "Household Head Occupation" column?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0022_790_22790047_qa_2/task.toml b/tasks/0022_790_22790047_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a08ca270c058f06c884d1ce75fe9c69f4fe3dd27
--- /dev/null
+++ b/tasks/0022_790_22790047_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0022_790_22790047_qa_2"
+description = "What is the highest household income recorded in the dataset after removing missing values in the \"Household Head Occupation\" column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0022/790/22790047.ipynb_qa_2"
+kaggle_dataset_name = "grosvenpaul/family-income-and-expenditure"
+gold_answer = "11815988"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "grosvenpaul__family-income-and-expenditure"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "grosvenpaul/family-income-and-expenditure"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "11815988"
+QUESTION = "What is the highest household income recorded in the dataset after removing missing values in the \"Household Head Occupation\" column?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0023_715_23715177_qa_2/instruction.md b/tasks/0023_715_23715177_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ff2885c1fe927c8b220111d53aa0bcf7a1b8788
--- /dev/null
+++ b/tasks/0023_715_23715177_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- ramen-ratings.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many brands have an average rating of 4.5 or higher and at least 2 reviews?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0023_715_23715177_qa_2/task.toml b/tasks/0023_715_23715177_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4c99fecb152f5e60e1ddb7afe7f50e25833db04b
--- /dev/null
+++ b/tasks/0023_715_23715177_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0023_715_23715177_qa_2"
+description = "How many brands have an average rating of 4.5 or higher and at least 2 reviews?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0023/715/23715177.ipynb_qa_2"
+kaggle_dataset_name = "residentmario/ramen-ratings"
+gold_answer = "20"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "residentmario__ramen-ratings"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "residentmario/ramen-ratings"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "20"
+QUESTION = "How many brands have an average rating of 4.5 or higher and at least 2 reviews?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0024_025_24025935_qa_3/instruction.md b/tasks/0024_025_24025935_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4c23aef2ef2410c90aae40016fffa3ca1324c186
--- /dev/null
+++ b/tasks/0024_025_24025935_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Accidental_Drug_Related_Deaths__2012-June_2017.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which drug was involved in the highest number of accidental death cases according to the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0024_025_24025935_qa_3/task.toml b/tasks/0024_025_24025935_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..32ea316cd90e5a4d92edae86552e728e0e6605bf
--- /dev/null
+++ b/tasks/0024_025_24025935_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0024_025_24025935_qa_3"
+description = "Which drug was involved in the highest number of accidental death cases according to the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0024/025/24025935.ipynb_qa_3"
+kaggle_dataset_name = "addynaik/ct-accidental-drug-related-deaths-2012june-2017"
+gold_answer = "Heroin"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "addynaik__ct-accidental-drug-related-deaths-2012june-2017"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "addynaik/ct-accidental-drug-related-deaths-2012june-2017"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Heroin"
+QUESTION = "Which drug was involved in the highest number of accidental death cases according to the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0024_158_24158944_qa_1/instruction.md b/tasks/0024_158_24158944_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ba14567b2fb5424b1ec6a5a0e60f691cf964a87c
--- /dev/null
+++ b/tasks/0024_158_24158944_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the percentage of benign (B) cases compared to malignant (M) cases in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0024_158_24158944_qa_1/task.toml b/tasks/0024_158_24158944_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cc1cf71a9e188fea2d595b1741c3b8a4befb206e
--- /dev/null
+++ b/tasks/0024_158_24158944_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0024_158_24158944_qa_1"
+description = "What is the percentage of benign (B) cases compared to malignant (M) cases in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0024/158/24158944.ipynb_qa_1"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "62.8% benign, 37.2% malignant"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "62.8% benign, 37.2% malignant"
+QUESTION = "What is the percentage of benign (B) cases compared to malignant (M) cases in the dataset?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0024_471_24471564_qa_5/instruction.md b/tasks/0024_471_24471564_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3aa3161ddec6225b1f43fae63c806e57c986d4a8
--- /dev/null
+++ b/tasks/0024_471_24471564_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- archive.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which category has received the most awards according to the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0024_471_24471564_qa_5/task.toml b/tasks/0024_471_24471564_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..22cd45db94ea392a41893e0d75195b272c7804b1
--- /dev/null
+++ b/tasks/0024_471_24471564_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0024_471_24471564_qa_5"
+description = "Which category has received the most awards according to the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0024/471/24471564.ipynb_qa_5"
+kaggle_dataset_name = "timemagazine/magazine-covers"
+gold_answer = "Politics"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "timemagazine__magazine-covers"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "timemagazine/magazine-covers"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Politics"
+QUESTION = "Which category has received the most awards according to the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0024_610_24610752_qa_3/instruction.md b/tasks/0024_610_24610752_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..03bf91617cbd2ed4d6affadf76336110ab9995e2
--- /dev/null
+++ b/tasks/0024_610_24610752_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of non-legendary Pokémon in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0024_610_24610752_qa_3/task.toml b/tasks/0024_610_24610752_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e33cc19698253c27513bc61465443773012b957f
--- /dev/null
+++ b/tasks/0024_610_24610752_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0024_610_24610752_qa_3"
+description = "What is the total number of non-legendary Pokémon in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0024/610/24610752.ipynb_qa_3"
+kaggle_dataset_name = "abcsds/pokemon"
+gold_answer = "735"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abcsds__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abcsds/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "735"
+QUESTION = "What is the total number of non-legendary Pokémon in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0024_650_24650942_qa_2/instruction.md b/tasks/0024_650_24650942_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..65c755cb653de2a4f317205faba6f76874ace1db
--- /dev/null
+++ b/tasks/0024_650_24650942_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- austin_weather.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After relabeling the weather event classes into three categories (Clear, Rain, Thunderstorm), what is the distribution of instances across these classes in the final dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as comma-separated <class>=<count> pairs in the order <label2>, <label3>, <label1>.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0024_650_24650942_qa_2/task.toml b/tasks/0024_650_24650942_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..35711d4cb2c8b4f3422976353cd441c555034052
--- /dev/null
+++ b/tasks/0024_650_24650942_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0024_650_24650942_qa_2"
+description = "After relabeling the weather event classes into three categories (Clear, Rain, Thunderstorm), what is the distribution of instances across these classes in the final dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0024/650/24650942.ipynb_qa_2"
+kaggle_dataset_name = "grubenm/austin-weather"
+gold_answer = "Clear=924, Rain=207, Thunderstorm=188"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "grubenm__austin-weather"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "grubenm/austin-weather"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Clear=924, Rain=207, Thunderstorm=188"
+QUESTION = "After relabeling the weather event classes into three categories (Clear, Rain, Thunderstorm), what is the distribution of instances across these classes in the final dataset?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0024_675_24675509_qa_1/instruction.md b/tasks/0024_675_24675509_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b2d739feaee7c1ff3fc23360db80eed1b6d81236
--- /dev/null
+++ b/tasks/0024_675_24675509_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Churn_Modelling.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of customers in the dataset have exited?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0024_675_24675509_qa_1/task.toml b/tasks/0024_675_24675509_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8141d56c66db250e6f79dd52477158a6274c809f
--- /dev/null
+++ b/tasks/0024_675_24675509_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0024_675_24675509_qa_1"
+description = "What percentage of customers in the dataset have exited?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0024/675/24675509.ipynb_qa_1"
+kaggle_dataset_name = "filippoo/deep-learning-az-ann"
+gold_answer = "20.37"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "filippoo__deep-learning-az-ann"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "filippoo/deep-learning-az-ann"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "20.37"
+QUESTION = "What percentage of customers in the dataset have exited?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0026_494_26494658_qa_4/instruction.md b/tasks/0026_494_26494658_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ab9a6cacec791b777041ba19a519860384fd4f13
--- /dev/null
+++ b/tasks/0026_494_26494658_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mnist.pkl.gz
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median number of samples per digit class in the training dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0026_494_26494658_qa_4/task.toml b/tasks/0026_494_26494658_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e1db966b43350ad07317d32781bd460165097fd3
--- /dev/null
+++ b/tasks/0026_494_26494658_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0026_494_26494658_qa_4"
+description = "What is the median number of samples per digit class in the training dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0026/494/26494658.ipynb_qa_4"
+kaggle_dataset_name = "weiouyang/test-dataset"
+gold_answer = "5936"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "weiouyang__test-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "weiouyang/test-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5936"
+QUESTION = "What is the median number of samples per digit class in the training dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0026_494_26494658_qa_5/instruction.md b/tasks/0026_494_26494658_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a48f87490c1270dc18b6474f77944e7b44d7daa8
--- /dev/null
+++ b/tasks/0026_494_26494658_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mnist.pkl.gz
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of pixels in all training images combined?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0026_494_26494658_qa_5/task.toml b/tasks/0026_494_26494658_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d26aab8505d45a9b7a0f47df2a075020277cf536
--- /dev/null
+++ b/tasks/0026_494_26494658_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0026_494_26494658_qa_5"
+description = "What is the total number of pixels in all training images combined?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0026/494/26494658.ipynb_qa_5"
+kaggle_dataset_name = "weiouyang/test-dataset"
+gold_answer = "47040000"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "weiouyang__test-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "weiouyang/test-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "47040000"
+QUESTION = "What is the total number of pixels in all training images combined?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0026_546_26546219_qa_2/instruction.md b/tasks/0026_546_26546219_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f2245c30834ec7785c14481c160d3db717ed0299
--- /dev/null
+++ b/tasks/0026_546_26546219_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- kc_house_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median price of houses in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0026_546_26546219_qa_2/task.toml b/tasks/0026_546_26546219_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3ca5ca10560f5642aaf6d94b1cfe3e5f7a3cee00
--- /dev/null
+++ b/tasks/0026_546_26546219_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0026_546_26546219_qa_2"
+description = "What is the median price of houses in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0026/546/26546219.ipynb_qa_2"
+kaggle_dataset_name = "harlfoxem/housesalesprediction"
+gold_answer = "450000"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "harlfoxem__housesalesprediction"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "450000"
+QUESTION = "What is the median price of houses in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0028_488_28488702_qa_1/instruction.md b/tasks/0028_488_28488702_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1a18b3bfa646b99348fc4a7e9518cd5c3891c357
--- /dev/null
+++ b/tasks/0028_488_28488702_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of variance is explained by the first linear discriminant after applying LDA to the Iris dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0028_488_28488702_qa_1/task.toml b/tasks/0028_488_28488702_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a7069adbc45ffdac411389e858d5c7266816b289
--- /dev/null
+++ b/tasks/0028_488_28488702_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0028_488_28488702_qa_1"
+description = "What percentage of variance is explained by the first linear discriminant after applying LDA to the Iris dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0028/488/28488702.ipynb_qa_1"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "99.128"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "99.128"
+QUESTION = "What percentage of variance is explained by the first linear discriminant after applying LDA to the Iris dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0029_136_29136731_qa_2/instruction.md b/tasks/0029_136_29136731_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4fb1761ffe1befb1c5fcb5840c58c948379e735b
--- /dev/null
+++ b/tasks/0029_136_29136731_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many samples and features are present in the preprocessed dataset used for modeling?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <samples>, <features> (comma-separated, numbers only).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0029_136_29136731_qa_2/task.toml b/tasks/0029_136_29136731_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c4031222eb72886fb59d802d851e1ac0c63ae156
--- /dev/null
+++ b/tasks/0029_136_29136731_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0029_136_29136731_qa_2"
+description = "How many samples and features are present in the preprocessed dataset used for modeling?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0029/136/29136731.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "768, 8"
+reward_mode_initial = "list"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "768, 8"
+QUESTION = "How many samples and features are present in the preprocessed dataset used for modeling?"
+REWARD_MODE = "list_csv"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0029_448_29448999_qa_5/instruction.md b/tasks/0029_448_29448999_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..26617a05d862f3d3d9852ea512ac63265f63c568
--- /dev/null
+++ b/tasks/0029_448_29448999_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median value of the RM (average number of rooms per dwelling) feature in the training dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0029_448_29448999_qa_5/task.toml b/tasks/0029_448_29448999_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ef36631020989be6aedc6833d228cd583b242b32
--- /dev/null
+++ b/tasks/0029_448_29448999_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0029_448_29448999_qa_5"
+description = "What is the median value of the RM (average number of rooms per dwelling) feature in the training dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0029/448/29448999.ipynb_qa_5"
+kaggle_dataset_name = "vikrishnan/boston-house-prices"
+gold_answer = "6.2275"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "vikrishnan__boston-house-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "vikrishnan/boston-house-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6.2275"
+QUESTION = "What is the median value of the RM (average number of rooms per dwelling) feature in the training dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0029_449_29449296_qa_3/instruction.md b/tasks/0029_449_29449296_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..73509511fc5f538b2e181b20dc0551047ba612ad
--- /dev/null
+++ b/tasks/0029_449_29449296_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many samples belong to each species in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0029_449_29449296_qa_3/task.toml b/tasks/0029_449_29449296_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..02b2f5c66e43a7904cf0322cca7867572ba97751
--- /dev/null
+++ b/tasks/0029_449_29449296_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0029_449_29449296_qa_3"
+description = "How many samples belong to each species in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0029/449/29449296.ipynb_qa_3"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "50"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "50"
+QUESTION = "How many samples belong to each species in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0030_688_30688656_qa_2/instruction.md b/tasks/0030_688_30688656_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e1ffc0fbdc36cdf8fe941346ec897b9893629e6
--- /dev/null
+++ b/tasks/0030_688_30688656_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- glove.6B.100d.txt
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many of the top 20 words most similar to 'bank' are proper nouns (e.g., company names like "ubs" or "citigroup")?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0030_688_30688656_qa_2/task.toml b/tasks/0030_688_30688656_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e5cc087e6f4a72a66a1fc580590d93565bfc1bba
--- /dev/null
+++ b/tasks/0030_688_30688656_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0030_688_30688656_qa_2"
+description = "How many of the top 20 words most similar to 'bank' are proper nouns (e.g., company names like \"ubs\" or \"citigroup\")?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0030/688/30688656.ipynb_qa_2"
+kaggle_dataset_name = "rtatman/glove-global-vectors-for-word-representation"
+gold_answer = "3"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rtatman__glove-global-vectors-for-word-representation"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rtatman/glove-global-vectors-for-word-representation"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3"
+QUESTION = "How many of the top 20 words most similar to 'bank' are proper nouns (e.g., company names like \"ubs\" or \"citigroup\")?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0030_858_30858491_qa_3/instruction.md b/tasks/0030_858_30858491_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ece1a387bb616775b09b4a08846ae9185be2df79
--- /dev/null
+++ b/tasks/0030_858_30858491_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- sales_data_sample.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Does the `SALES` column still contain outliers in the dataset after IQR-based filtering, as indicated by the box plot visualization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0030_858_30858491_qa_3/task.toml b/tasks/0030_858_30858491_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9442f8ea9b17b333549675f0325bdeb39825e07d
--- /dev/null
+++ b/tasks/0030_858_30858491_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0030_858_30858491_qa_3"
+description = "Does the `SALES` column still contain outliers in the dataset after IQR-based filtering, as indicated by the box plot visualization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0030/858/30858491.ipynb_qa_3"
+kaggle_dataset_name = "kyanyoga/sample-sales-data"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 3
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kyanyoga__sample-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kyanyoga/sample-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Does the `SALES` column still contain outliers in the dataset after IQR-based filtering, as indicated by the box plot visualization?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0031_326_31326046_qa_5/instruction.md b/tasks/0031_326_31326046_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d2695dd6894df3d2a8c6486b50f015e1ca0e8b18
--- /dev/null
+++ b/tasks/0031_326_31326046_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- UCI_Credit_Card.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the original proportion of defaulters (before SMOTE application) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0031_326_31326046_qa_5/task.toml b/tasks/0031_326_31326046_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d20e6fd21962599d752706d9f7f14caa8b6b3c1e
--- /dev/null
+++ b/tasks/0031_326_31326046_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0031_326_31326046_qa_5"
+description = "What is the original proportion of defaulters (before SMOTE application) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/326/31326046.ipynb_qa_5"
+kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset"
+gold_answer = "22.12%"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__default-of-credit-card-clients-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "22.12%"
+QUESTION = "What is the original proportion of defaulters (before SMOTE application) in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0031_326_31326436_qa_3/instruction.md b/tasks/0031_326_31326436_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..49755a1d5ca3cb85f7feffe4cf93e3c3edeff2b1
--- /dev/null
+++ b/tasks/0031_326_31326436_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Is the mean age of patients with diabetes statistically higher than those without diabetes in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0031_326_31326436_qa_3/task.toml b/tasks/0031_326_31326436_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..23361d7d60f7529007cfae12fb11accf2108d2af
--- /dev/null
+++ b/tasks/0031_326_31326436_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0031_326_31326436_qa_3"
+description = "Is the mean age of patients with diabetes statistically higher than those without diabetes in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/326/31326436.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Is the mean age of patients with diabetes statistically higher than those without diabetes in the dataset?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0031_523_31523942_qa_4/instruction.md b/tasks/0031_523_31523942_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fc66f74044c2bf12c708ca71e55b6b2dc69f599c
--- /dev/null
+++ b/tasks/0031_523_31523942_qa_4/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- column_3C_weka.csv
+- column_2C_weka.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference in average pelvic_radius between the Normal and Hernia classes in the data3c dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0031_523_31523942_qa_4/task.toml b/tasks/0031_523_31523942_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9d90cf62ba592b45e2af43bcb9e9a47cc303afd7
--- /dev/null
+++ b/tasks/0031_523_31523942_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0031_523_31523942_qa_4"
+description = "What is the difference in average pelvic_radius between the Normal and Hernia classes in the data3c dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/523/31523942.ipynb_qa_4"
+kaggle_dataset_name = "uciml/biomechanical-features-of-orthopedic-patients"
+gold_answer = "7.42"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__biomechanical-features-of-orthopedic-patients"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/biomechanical-features-of-orthopedic-patients"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "7.42"
+QUESTION = "What is the difference in average pelvic_radius between the Normal and Hernia classes in the data3c dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0031_872_31872884_qa_1/instruction.md b/tasks/0031_872_31872884_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9d814cb7eed4624955c67a785604879aa8dc77d1
--- /dev/null
+++ b/tasks/0031_872_31872884_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest correlation coefficient between any two sales regions (NA, EU, JP, Other, and Global) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0031_872_31872884_qa_1/task.toml b/tasks/0031_872_31872884_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0b6cbf41dbbba105dc45088eed6cd0dd69fae0c6
--- /dev/null
+++ b/tasks/0031_872_31872884_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0031_872_31872884_qa_1"
+description = "What is the highest correlation coefficient between any two sales regions (NA, EU, JP, Other, and Global) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/872/31872884.ipynb_qa_1"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "0.941499"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.941499"
+QUESTION = "What is the highest correlation coefficient between any two sales regions (NA, EU, JP, Other, and Global) in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0031_931_31931380_qa_5/instruction.md b/tasks/0031_931_31931380_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6c41ab128ee1fe1b18d1c6cd95d3703b8fede419
--- /dev/null
+++ b/tasks/0031_931_31931380_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- summer.csv
+- winter.csv
+- dictionary.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of medals awarded to female athletes in the Summer Olympics dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0031_931_31931380_qa_5/task.toml b/tasks/0031_931_31931380_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9e2f6ff4b20fd5148381bc8da5696a54f4ab28fc
--- /dev/null
+++ b/tasks/0031_931_31931380_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0031_931_31931380_qa_5"
+description = "What is the total number of medals awarded to female athletes in the Summer Olympics dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/931/31931380.ipynb_qa_5"
+kaggle_dataset_name = "the-guardian/olympic-games"
+gold_answer = "8419"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "the-guardian__olympic-games"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "the-guardian/olympic-games"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "8419"
+QUESTION = "What is the total number of medals awarded to female athletes in the Summer Olympics dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0031_950_31950412_qa_5/instruction.md b/tasks/0031_950_31950412_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9398f9782f06c7a93621c5c309adf24a9f66e8df
--- /dev/null
+++ b/tasks/0031_950_31950412_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average sepal width in centimeters for the Iris-versicolor species according to the dataset analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0031_950_31950412_qa_5/task.toml b/tasks/0031_950_31950412_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b11d64419eca516a74bc6ef0a6e73bee919c256b
--- /dev/null
+++ b/tasks/0031_950_31950412_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0031_950_31950412_qa_5"
+description = "What is the average sepal width in centimeters for the Iris-versicolor species according to the dataset analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/950/31950412.ipynb_qa_5"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "2.770"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2.770"
+QUESTION = "What is the average sepal width in centimeters for the Iris-versicolor species according to the dataset analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0032_205_32205594_qa_1/instruction.md b/tasks/0032_205_32205594_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d3ae50200835f6614aeae931eb91e644b1b64c25
--- /dev/null
+++ b/tasks/0032_205_32205594_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- SPAM text message 20170820 - Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average difference in message length between spam and ham messages in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0032_205_32205594_qa_1/task.toml b/tasks/0032_205_32205594_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..92493754fd646eeec66ca9483bc56b636d12018a
--- /dev/null
+++ b/tasks/0032_205_32205594_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0032_205_32205594_qa_1"
+description = "What is the average difference in message length between spam and ham messages in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0032/205/32205594.ipynb_qa_1"
+kaggle_dataset_name = "team-ai/spam-text-message-classification"
+gold_answer = "66.54 characters"
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "team-ai__spam-text-message-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "team-ai/spam-text-message-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "66.54 characters"
+QUESTION = "What is the average difference in message length between spam and ham messages in the dataset?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0032_281_32281132_qa_4/instruction.md b/tasks/0032_281_32281132_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1b9fec7957462384f097ae3b516102f012c2f75c
--- /dev/null
+++ b/tasks/0032_281_32281132_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which cap-shape is most frequently observed in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0032_281_32281132_qa_4/task.toml b/tasks/0032_281_32281132_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ea5e7e3d63acc363661dce12626b0b076c93092a
--- /dev/null
+++ b/tasks/0032_281_32281132_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0032_281_32281132_qa_4"
+description = "Which cap-shape is most frequently observed in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0032/281/32281132.ipynb_qa_4"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "x"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "x"
+QUESTION = "Which cap-shape is most frequently observed in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0032_281_32281132_qa_5/instruction.md b/tasks/0032_281_32281132_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cc0d9598e501cd7d2a622917fe5e57b6a5c0f306
--- /dev/null
+++ b/tasks/0032_281_32281132_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest number of unique categories in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0032_281_32281132_qa_5/task.toml b/tasks/0032_281_32281132_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3cf0ee2aac2165ab59623f29892153eb3a6a83a1
--- /dev/null
+++ b/tasks/0032_281_32281132_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0032_281_32281132_qa_5"
+description = "Which feature has the highest number of unique categories in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0032/281/32281132.ipynb_qa_5"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "gill-color"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "gill-color"
+QUESTION = "Which feature has the highest number of unique categories in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0032_340_32340712_qa_1/instruction.md b/tasks/0032_340_32340712_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ef357a78ce999c4b1de4b35eb097b2c3ce543f46
--- /dev/null
+++ b/tasks/0032_340_32340712_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Hotel_Reviews.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of reviews in the dataset contain missing latitude and longitude information?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0032_340_32340712_qa_1/task.toml b/tasks/0032_340_32340712_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..06f5abe6de3f3864f30004793da7d03e044b3633
--- /dev/null
+++ b/tasks/0032_340_32340712_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0032_340_32340712_qa_1"
+description = "What percentage of reviews in the dataset contain missing latitude and longitude information?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0032/340/32340712.ipynb_qa_1"
+kaggle_dataset_name = "jiashenliu/515k-hotel-reviews-data-in-europe"
+gold_answer = "0.63"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "jiashenliu__515k-hotel-reviews-data-in-europe"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jiashenliu/515k-hotel-reviews-data-in-europe"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.63"
+QUESTION = "What percentage of reviews in the dataset contain missing latitude and longitude information?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0032_842_32842401_qa_1/instruction.md b/tasks/0032_842_32842401_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..86b86b709d536adfd864677e700ad48994379606
--- /dev/null
+++ b/tasks/0032_842_32842401_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between smoker status and insurance charges in the dataset after encoding categorical variables?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0032_842_32842401_qa_1/task.toml b/tasks/0032_842_32842401_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..525fc0740b007e75846fcf1eaa415ce5f5e9364c
--- /dev/null
+++ b/tasks/0032_842_32842401_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0032_842_32842401_qa_1"
+description = "What is the correlation coefficient between smoker status and insurance charges in the dataset after encoding categorical variables?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0032/842/32842401.ipynb_qa_1"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "0.787251"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.787251"
+QUESTION = "What is the correlation coefficient between smoker status and insurance charges in the dataset after encoding categorical variables?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0033_083_33083379_qa_4/instruction.md b/tasks/0033_083_33083379_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..92857fae383e8e4b797c581ad0d6c2eabd666827
--- /dev/null
+++ b/tasks/0033_083_33083379_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the prior probability assigned to each species in this Naive Bayes implementation based on the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0033_083_33083379_qa_4/task.toml b/tasks/0033_083_33083379_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d8e5e6398d5bc7e928d180c0cb54888e40dcb726
--- /dev/null
+++ b/tasks/0033_083_33083379_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0033_083_33083379_qa_4"
+description = "What is the prior probability assigned to each species in this Naive Bayes implementation based on the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0033/083/33083379.ipynb_qa_4"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "0.3333333333333333"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.3333333333333333"
+QUESTION = "What is the prior probability assigned to each species in this Naive Bayes implementation based on the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0033_198_33198049_qa_4/instruction.md b/tasks/0033_198_33198049_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7589883392be966b52971daec493cf92a5de5a8d
--- /dev/null
+++ b/tasks/0033_198_33198049_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest maximum rating given by any user to a joke in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0033_198_33198049_qa_4/task.toml b/tasks/0033_198_33198049_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e7b5f57daed0bdca652527d8267378a56c0ac9b6
--- /dev/null
+++ b/tasks/0033_198_33198049_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0033_198_33198049_qa_4"
+description = "What is the highest maximum rating given by any user to a joke in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0033/198/33198049.ipynb_qa_4"
+kaggle_dataset_name = "aakaashjois/jester-collaborative-filtering-dataset"
+gold_answer = "10.00"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "aakaashjois__jester-collaborative-filtering-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "aakaashjois/jester-collaborative-filtering-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "10.00"
+QUESTION = "What is the highest maximum rating given by any user to a joke in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0033_420_33420599_qa_1/instruction.md b/tasks/0033_420_33420599_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e92c17011b40ae921c688f9d6cce880af5eabb11
--- /dev/null
+++ b/tasks/0033_420_33420599_qa_1/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which video game achieved the highest global sales in the dataset, and what was the exact global sales figure?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <game name>, <sales figure> (comma-separated, name first, keep decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0033_420_33420599_qa_1/task.toml b/tasks/0033_420_33420599_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..877892a9dd46c854dd74e0e89ac8fc267a33f396
--- /dev/null
+++ b/tasks/0033_420_33420599_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0033_420_33420599_qa_1"
+description = "Which video game achieved the highest global sales in the dataset, and what was the exact global sales figure?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0033/420/33420599.ipynb_qa_1"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Wii Sports, 82.74"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Wii Sports, 82.74"
+QUESTION = "Which video game achieved the highest global sales in the dataset, and what was the exact global sales figure?"
+REWARD_MODE = "list_csv"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0033_700_33700089_qa_1/instruction.md b/tasks/0033_700_33700089_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8adcdfead65ed5328f0420442bf4ea7eeb3a265d
--- /dev/null
+++ b/tasks/0033_700_33700089_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+- database.sqlite
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many samples are included in the training set after the train-test split with a test size of 20%?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0033_700_33700089_qa_1/task.toml b/tasks/0033_700_33700089_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..84b00a865b5a5f617eaafd43000cd3278922863b
--- /dev/null
+++ b/tasks/0033_700_33700089_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0033_700_33700089_qa_1"
+description = "How many samples are included in the training set after the train-test split with a test size of 20%?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0033/700/33700089.ipynb_qa_1"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "120"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "120"
+QUESTION = "How many samples are included in the training set after the train-test split with a test size of 20%?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0034_023_34023168_qa_2/instruction.md b/tasks/0034_023_34023168_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b1d8105120bfa75808a9b66e04c3b8ed0b432f7b
--- /dev/null
+++ b/tasks/0034_023_34023168_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winemag-data-130k-v2.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest price of a wine in the dataset, and which specific wine has this price?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <price>, <wine name> (comma-separated, price first, keep decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_023_34023168_qa_2/task.toml b/tasks/0034_023_34023168_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..aed9f60687c15a9d0dd6119e49e03185de932e80
--- /dev/null
+++ b/tasks/0034_023_34023168_qa_2/task.toml
@@ -0,0 +1,60 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0034_023_34023168_qa_2"
+description = "What is the highest price of a wine in the dataset, and which specific wine has this price?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/023/34023168.ipynb_qa_2"
+kaggle_dataset_name = "zynicide/wine-reviews"
+gold_answer = "3300.0, Château les Ormes Sorbet 2013 Médoc"
+reward_mode_initial = "flexible"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "zynicide__wine-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zynicide/wine-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3300.0, Château les Ormes Sorbet 2013 Médoc"
+QUESTION = "What is the highest price of a wine in the dataset, and which specific wine has this price?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0034_200_34200101_qa_1/instruction.md b/tasks/0034_200_34200101_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1ba22d2410533c195011348d73856226e65dfc29
--- /dev/null
+++ b/tasks/0034_200_34200101_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which variable (age, bmi, or children) has the highest coefficient in the linear regression model for predicting medical charges?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_200_34200101_qa_1/task.toml b/tasks/0034_200_34200101_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d0e7d04919e4998efbf15848bae3fa37cff4f5fd
--- /dev/null
+++ b/tasks/0034_200_34200101_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0034_200_34200101_qa_1"
+description = "Which variable (age, bmi, or children) has the highest coefficient in the linear regression model for predicting medical charges?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/200/34200101.ipynb_qa_1"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "children"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "children"
+QUESTION = "Which variable (age, bmi, or children) has the highest coefficient in the linear regression model for predicting medical charges?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0034_233_34233505_qa_2/instruction.md b/tasks/0034_233_34233505_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ff8e4f824618dfe970c9e5e49605b4f47b05d726
--- /dev/null
+++ b/tasks/0034_233_34233505_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Reviews.csv
+- database.sqlite
+- hashes.txt
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the ratio of positive reviews to negative reviews in the final cleaned dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_233_34233505_qa_2/task.toml b/tasks/0034_233_34233505_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..24a49453c24f9f55f99227a75dccf85be329734b
--- /dev/null
+++ b/tasks/0034_233_34233505_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0034_233_34233505_qa_2"
+description = "What is the ratio of positive reviews to negative reviews in the final cleaned dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/233/34233505.ipynb_qa_2"
+kaggle_dataset_name = "snap/amazon-fine-food-reviews"
+gold_answer = "5.38"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "snap__amazon-fine-food-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "snap/amazon-fine-food-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5.38"
+QUESTION = "What is the ratio of positive reviews to negative reviews in the final cleaned dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0034_233_34233505_qa_4/instruction.md b/tasks/0034_233_34233505_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..617a88c87b40a5027fc7a2d4f855f2bf279e4a04
--- /dev/null
+++ b/tasks/0034_233_34233505_qa_4/instruction.md
@@ -0,0 +1,19 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Reviews.csv
+- database.sqlite
+- hashes.txt
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of the dataset was removed due to invalid HelpfulnessNumerator/HelpfulnessDenominator values?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Express the value as a percentage (e.g. 0.00055), not a fraction.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_233_34233505_qa_4/task.toml b/tasks/0034_233_34233505_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..10d475d18665bbaf73966465378c3e320c218804
--- /dev/null
+++ b/tasks/0034_233_34233505_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0034_233_34233505_qa_4"
+description = "What percentage of the dataset was removed due to invalid HelpfulnessNumerator/HelpfulnessDenominator values?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/233/34233505.ipynb_qa_4"
+kaggle_dataset_name = "snap/amazon-fine-food-reviews"
+gold_answer = "0.00055%"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "snap__amazon-fine-food-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "snap/amazon-fine-food-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.00055%"
+QUESTION = "What percentage of the dataset was removed due to invalid HelpfulnessNumerator/HelpfulnessDenominator values?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0034_568_34568948_qa_5/instruction.md b/tasks/0034_568_34568948_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f359e91c4f81f5617fc23f209526b902268cfe31
--- /dev/null
+++ b/tasks/0034_568_34568948_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- auto-mpg.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean weight of vehicles in the dataset, rounded to two decimal places?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_568_34568948_qa_5/task.toml b/tasks/0034_568_34568948_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d15acccf3501e44a4c2d9631e5532c92cf272409
--- /dev/null
+++ b/tasks/0034_568_34568948_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0034_568_34568948_qa_5"
+description = "What is the mean weight of vehicles in the dataset, rounded to two decimal places?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/568/34568948.ipynb_qa_5"
+kaggle_dataset_name = "uciml/autompg-dataset"
+gold_answer = "2970.42"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__autompg-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/autompg-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2970.42"
+QUESTION = "What is the mean weight of vehicles in the dataset, rounded to two decimal places?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0034_651_34651965_qa_2/instruction.md b/tasks/0034_651_34651965_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..52cbaa1855ee6ae62a1bfb61f77eff4b48faf265
--- /dev/null
+++ b/tasks/0034_651_34651965_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- austin_weather.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the R-squared score of the model's performance on the test dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_651_34651965_qa_2/task.toml b/tasks/0034_651_34651965_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f42b797e74c2996a00020ad564f02af811cb2f1b
--- /dev/null
+++ b/tasks/0034_651_34651965_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0034_651_34651965_qa_2"
+description = "What is the R-squared score of the model's performance on the test dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/651/34651965.ipynb_qa_2"
+kaggle_dataset_name = "grubenm/austin-weather"
+gold_answer = "1.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "grubenm__austin-weather"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "grubenm/austin-weather"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.0"
+QUESTION = "What is the R-squared score of the model's performance on the test dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0034_768_34768850_qa_2/instruction.md b/tasks/0034_768_34768850_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7f22a13bf2f487aee438914698f6181784c39173
--- /dev/null
+++ b/tasks/0034_768_34768850_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Womens Clothing E-Commerce Reviews.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which clothing class has the highest number of customer reviews in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_768_34768850_qa_2/task.toml b/tasks/0034_768_34768850_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6be30db71cf8fe29ede05d53ebebb5ced78d6b17
--- /dev/null
+++ b/tasks/0034_768_34768850_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0034_768_34768850_qa_2"
+description = "Which clothing class has the highest number of customer reviews in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/768/34768850.ipynb_qa_2"
+kaggle_dataset_name = "nicapotato/womens-ecommerce-clothing-reviews"
+gold_answer = "Dresses"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "nicapotato__womens-ecommerce-clothing-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "nicapotato/womens-ecommerce-clothing-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Dresses"
+QUESTION = "Which clothing class has the highest number of customer reviews in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0034_793_34793224_qa_1/instruction.md b/tasks/0034_793_34793224_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4ccd52fbaf49239ab0ba02e4f367ad1fe75745c2
--- /dev/null
+++ b/tasks/0034_793_34793224_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of customers in the dataset have churned after data preprocessing?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_793_34793224_qa_1/task.toml b/tasks/0034_793_34793224_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..05ae491f4ba6b51e74aaaef7c38ee722d7511471
--- /dev/null
+++ b/tasks/0034_793_34793224_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0034_793_34793224_qa_1"
+description = "What percentage of customers in the dataset have churned after data preprocessing?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/793/34793224.ipynb_qa_1"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "26.6"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "26.6"
+QUESTION = "What percentage of customers in the dataset have churned after data preprocessing?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0035_122_35122628_qa_1/instruction.md b/tasks/0035_122_35122628_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0f4c0b735bb4f6f8dafa1ac926e3c2a5d656e011
--- /dev/null
+++ b/tasks/0035_122_35122628_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many unique words (features) were identified in the spam dataset after preprocessing text data for the bag-of-words model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0035_122_35122628_qa_1/task.toml b/tasks/0035_122_35122628_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bd3b04f615b6dc4e3028e1ea6e8fc663b68f4da5
--- /dev/null
+++ b/tasks/0035_122_35122628_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0035_122_35122628_qa_1"
+description = "How many unique words (features) were identified in the spam dataset after preprocessing text data for the bag-of-words model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0035/122/35122628.ipynb_qa_1"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "8615"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "8615"
+QUESTION = "How many unique words (features) were identified in the spam dataset after preprocessing text data for the bag-of-words model?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0035_188_35188217_qa_4/instruction.md b/tasks/0035_188_35188217_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1f4acf68320540da09cdcc8473afd6941a21d00d
--- /dev/null
+++ b/tasks/0035_188_35188217_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- SolarPrediction.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many hourly data points were included in the analysis after aggregating the dataset by month, day, and hour?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0035_188_35188217_qa_4/task.toml b/tasks/0035_188_35188217_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ecea9bec6cf7bb721e56a920b214057f29d52d28
--- /dev/null
+++ b/tasks/0035_188_35188217_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0035_188_35188217_qa_4"
+description = "How many hourly data points were included in the analysis after aggregating the dataset by month, day, and hour?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0035/188/35188217.ipynb_qa_4"
+kaggle_dataset_name = "dronio/SolarEnergy"
+gold_answer = "2,777"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "dronio__SolarEnergy"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "dronio/SolarEnergy"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2,777"
+QUESTION = "How many hourly data points were included in the analysis after aggregating the dataset by month, day, and hour?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0035_242_35242928_qa_2/instruction.md b/tasks/0035_242_35242928_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4593793b7aeb31b7cab412bcf251e835ecbc001f
--- /dev/null
+++ b/tasks/0035_242_35242928_qa_2/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- matches.csv
+- deliveries.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which player has won the most "Player of the Match" awards in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0035_242_35242928_qa_2/task.toml b/tasks/0035_242_35242928_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..16b4c4a861443a5981cbe2f72c9369c47f3ffc52
--- /dev/null
+++ b/tasks/0035_242_35242928_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0035_242_35242928_qa_2"
+description = "Which player has won the most \"Player of the Match\" awards in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0035/242/35242928.ipynb_qa_2"
+kaggle_dataset_name = "manasgarg/ipl"
+gold_answer = "CH Gayle"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "manasgarg__ipl"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "manasgarg/ipl"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "CH Gayle"
+QUESTION = "Which player has won the most \"Player of the Match\" awards in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0035_247_35247886_qa_1/instruction.md b/tasks/0035_247_35247886_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..77f5958f15a8191eccf65089e0e52df270fb58b9
--- /dev/null
+++ b/tasks/0035_247_35247886_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+- database.sqlite
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the prior probability of each species (Iris-setosa, Iris-versicolor, Iris-virginica) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0035_247_35247886_qa_1/task.toml b/tasks/0035_247_35247886_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..37a75da012d307a7bffb874422f04ff0f67ea286
--- /dev/null
+++ b/tasks/0035_247_35247886_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0035_247_35247886_qa_1"
+description = "What is the prior probability of each species (Iris-setosa, Iris-versicolor, Iris-virginica) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0035/247/35247886.ipynb_qa_1"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "0.3333"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.3333"
+QUESTION = "What is the prior probability of each species (Iris-setosa, Iris-versicolor, Iris-virginica) in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0035_391_35391770_qa_1/instruction.md b/tasks/0035_391_35391770_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..acb25125bf2b9c91a26bbae84d62316916397539
--- /dev/null
+++ b/tasks/0035_391_35391770_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Salary_Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the coefficient of determination (R²) for the linear regression model trained on this dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0035_391_35391770_qa_1/task.toml b/tasks/0035_391_35391770_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..abd15db9034b6dff5719bf5673108fcaa03e0d22
--- /dev/null
+++ b/tasks/0035_391_35391770_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0035_391_35391770_qa_1"
+description = "What is the coefficient of determination (R²) for the linear regression model trained on this dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0035/391/35391770.ipynb_qa_1"
+kaggle_dataset_name = "rohankayan/years-of-experience-and-salary-dataset"
+gold_answer = "0.9663144321580247"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rohankayan__years-of-experience-and-salary-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rohankayan/years-of-experience-and-salary-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.9663144321580247"
+QUESTION = "What is the coefficient of determination (R²) for the linear regression model trained on this dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0035_456_35456170_qa_5/instruction.md b/tasks/0035_456_35456170_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e6290c40b4a0ca48ecf03d502ba88ba710e68667
--- /dev/null
+++ b/tasks/0035_456_35456170_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest skewness in the dataset before transformation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0035_456_35456170_qa_5/task.toml b/tasks/0035_456_35456170_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..440773f94565dce7fe30f8e3e55a6d52e08d75cb
--- /dev/null
+++ b/tasks/0035_456_35456170_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0035_456_35456170_qa_5"
+description = "Which feature has the highest skewness in the dataset before transformation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0035/456/35456170.ipynb_qa_5"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "area_se"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "area_se"
+QUESTION = "Which feature has the highest skewness in the dataset before transformation?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0035_980_35980933_qa_5/instruction.md b/tasks/0035_980_35980933_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fa73948c6d5d84f9e1d2532cbcaba02bf9a05e8d
--- /dev/null
+++ b/tasks/0035_980_35980933_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the lowest mean value in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0035_980_35980933_qa_5/task.toml b/tasks/0035_980_35980933_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7f902fb2711b0d4af08b421851734e7cba8ce292
--- /dev/null
+++ b/tasks/0035_980_35980933_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0035_980_35980933_qa_5"
+description = "Which feature has the lowest mean value in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0035/980/35980933.ipynb_qa_5"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "smoothness_worst"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "fractal_dimension_se"
+QUESTION = "Which feature has the lowest mean value in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0036_186_36186441_qa_2/instruction.md b/tasks/0036_186_36186441_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d077fdd576580ac6e84de59c3b5dd24c8e8eb8da
--- /dev/null
+++ b/tasks/0036_186_36186441_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the threshold value used to classify Pokémon as having a "powerful" Attack stat?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0036_186_36186441_qa_2/task.toml b/tasks/0036_186_36186441_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..197265fd97c135e0fb92b737a780dde28fb04ad2
--- /dev/null
+++ b/tasks/0036_186_36186441_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0036_186_36186441_qa_2"
+description = "What is the threshold value used to classify Pokémon as having a \"powerful\" Attack stat?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0036/186/36186441.ipynb_qa_2"
+kaggle_dataset_name = "abcsds/pokemon"
+gold_answer = "79.00125"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abcsds__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abcsds/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "79.00125"
+QUESTION = "What is the threshold value used to classify Pokémon as having a \"powerful\" Attack stat?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0037_631_37631084_qa_2/instruction.md b/tasks/0037_631_37631084_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c80a231536431db0965dd70118c84c11ebe96832
--- /dev/null
+++ b/tasks/0037_631_37631084_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- archive.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+In which decade did the highest proportion of Nobel laureates originate from the United States of America?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0037_631_37631084_qa_2/task.toml b/tasks/0037_631_37631084_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b01464bfb3366af859c6984e5caeeff5e87361b4
--- /dev/null
+++ b/tasks/0037_631_37631084_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0037_631_37631084_qa_2"
+description = "In which decade did the highest proportion of Nobel laureates originate from the United States of America?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0037/631/37631084.ipynb_qa_2"
+kaggle_dataset_name = "nobelfoundation/nobel-laureates"
+gold_answer = "2000s"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "nobelfoundation__nobel-laureates"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "nobelfoundation/nobel-laureates"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2000s"
+QUESTION = "In which decade did the highest proportion of Nobel laureates originate from the United States of America?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0037_631_37631084_qa_3/instruction.md b/tasks/0037_631_37631084_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..dd7f1e3be96489a04df09a6d1c4a044a8cb023f6
--- /dev/null
+++ b/tasks/0037_631_37631084_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- archive.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Who was the first woman to win a Nobel Prize, and in which category and year did she win?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list: <name>, <category>, <year>.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0037_631_37631084_qa_3/task.toml b/tasks/0037_631_37631084_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b64ee3a95de6383650eda87be8b915a248219562
--- /dev/null
+++ b/tasks/0037_631_37631084_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0037_631_37631084_qa_3"
+description = "Who was the first woman to win a Nobel Prize, and in which category and year did she win?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0037/631/37631084.ipynb_qa_3"
+kaggle_dataset_name = "nobelfoundation/nobel-laureates"
+gold_answer = "Marie Curie, Physics, 1903"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "nobelfoundation__nobel-laureates"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "nobelfoundation/nobel-laureates"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Marie Curie, Physics, 1903"
+QUESTION = "Who was the first woman to win a Nobel Prize, and in which category and year did she win?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0038_189_38189340_qa_1/instruction.md b/tasks/0038_189_38189340_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..097a411cb65f24619c2fb200ddca82bcd0bc84ac
--- /dev/null
+++ b/tasks/0038_189_38189340_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Social_Network_Ads.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest test accuracy achieved among the different gradient descent implementations in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0038_189_38189340_qa_1/task.toml b/tasks/0038_189_38189340_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2f97b2d071a4bb0bf2fe55701a8dab4a14815543
--- /dev/null
+++ b/tasks/0038_189_38189340_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0038_189_38189340_qa_1"
+description = "What is the highest test accuracy achieved among the different gradient descent implementations in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0038/189/38189340.ipynb_qa_1"
+kaggle_dataset_name = "dragonheir/logistic-regression"
+gold_answer = "0.86"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "dragonheir__logistic-regression"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "dragonheir/logistic-regression"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.86"
+QUESTION = "What is the highest test accuracy achieved among the different gradient descent implementations in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0038_316_38316301_qa_1/instruction.md b/tasks/0038_316_38316301_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9534b3cf00dbd04b3afc260d613e9368b9d87922
--- /dev/null
+++ b/tasks/0038_316_38316301_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- breastCancer.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the total number of missing values in the 'bare_nucleoli' column before imputation in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0038_316_38316301_qa_1/task.toml b/tasks/0038_316_38316301_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..86384a593475356543080401bd27415895b7aaf3
--- /dev/null
+++ b/tasks/0038_316_38316301_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0038_316_38316301_qa_1"
+description = "What was the total number of missing values in the 'bare_nucleoli' column before imputation in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0038/316/38316301.ipynb_qa_1"
+kaggle_dataset_name = "roustekbio/breast-cancer-csv"
+gold_answer = "16"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "roustekbio__breast-cancer-csv"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "roustekbio/breast-cancer-csv"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "16"
+QUESTION = "What was the total number of missing values in the 'bare_nucleoli' column before imputation in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0038_910_38910811_qa_2/instruction.md b/tasks/0038_910_38910811_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2f09321efd1ca2ba672754ebe6b2c655d189991a
--- /dev/null
+++ b/tasks/0038_910_38910811_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the exact difference in total Global Sales between the X360 and PS3 platforms as calculated in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0038_910_38910811_qa_2/task.toml b/tasks/0038_910_38910811_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..75dbcc5519cf7e746b8e998df02087458f0a2311
--- /dev/null
+++ b/tasks/0038_910_38910811_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0038_910_38910811_qa_2"
+description = "What is the exact difference in total Global Sales between the X360 and PS3 platforms as calculated in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0038/910/38910811.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "22.12"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "22.12"
+QUESTION = "What is the exact difference in total Global Sales between the X360 and PS3 platforms as calculated in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0038_910_38910811_qa_5/instruction.md b/tasks/0038_910_38910811_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e4b36ad254688371984cfd9ca6602a5c2a18c777
--- /dev/null
+++ b/tasks/0038_910_38910811_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the combined total of North American Sales for all three platforms (X360, PS3, and Wii) presented in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0038_910_38910811_qa_5/task.toml b/tasks/0038_910_38910811_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..016575cbd0d34794705005b7133f0cc9f962c2cd
--- /dev/null
+++ b/tasks/0038_910_38910811_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0038_910_38910811_qa_5"
+description = "What is the combined total of North American Sales for all three platforms (X360, PS3, and Wii) presented in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0038/910/38910811.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "1501.02"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1501.02"
+QUESTION = "What is the combined total of North American Sales for all three platforms (X360, PS3, and Wii) presented in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0039_131_39131612_qa_1/instruction.md b/tasks/0039_131_39131612_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3a794863db37e573297109d7bc8ba101d0b55a49
--- /dev/null
+++ b/tasks/0039_131_39131612_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which customer segment has the highest churn rate when combining tenure duration and contract type analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0039_131_39131612_qa_1/task.toml b/tasks/0039_131_39131612_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6c47d792ae9d9ac69700d5a4dc2504cd3c407a57
--- /dev/null
+++ b/tasks/0039_131_39131612_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0039_131_39131612_qa_1"
+description = "Which customer segment has the highest churn rate when combining tenure duration and contract type analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/131/39131612.ipynb_qa_1"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "Month-to-month contracts with tenure less than 12 months"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Month-to-month contracts with tenure less than 12 months"
+QUESTION = "Which customer segment has the highest churn rate when combining tenure duration and contract type analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0039_477_39477592_qa_5/instruction.md b/tasks/0039_477_39477592_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8477e47abb0d8198410d2d56e5121368dd8ff4ef
--- /dev/null
+++ b/tasks/0039_477_39477592_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the training accuracy of the Random Forest model trained on the PCA-reduced dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0039_477_39477592_qa_5/task.toml b/tasks/0039_477_39477592_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b40a8958d84129e8c36594ff5e87b1a14c4aa88d
--- /dev/null
+++ b/tasks/0039_477_39477592_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0039_477_39477592_qa_5"
+description = "What is the training accuracy of the Random Forest model trained on the PCA-reduced dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/477/39477592.ipynb_qa_5"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "1.0"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.0"
+QUESTION = "What is the training accuracy of the Random Forest model trained on the PCA-reduced dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0039_489_39489585_qa_2/instruction.md b/tasks/0039_489_39489585_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7651d10724e8561967edd429d9641b648f49b7c2
--- /dev/null
+++ b/tasks/0039_489_39489585_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which generation has the fewest Pokémon entries in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0039_489_39489585_qa_2/task.toml b/tasks/0039_489_39489585_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0c68748d57a57c7113070b2b9dfab50405139404
--- /dev/null
+++ b/tasks/0039_489_39489585_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0039_489_39489585_qa_2"
+description = "Which generation has the fewest Pokémon entries in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/489/39489585.ipynb_qa_2"
+kaggle_dataset_name = "rounakbanik/pokemon"
+gold_answer = "6"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rounakbanik__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rounakbanik/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6"
+QUESTION = "Which generation has the fewest Pokémon entries in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0039_599_39599874_qa_4/instruction.md b/tasks/0039_599_39599874_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..53a1c756eb87995e050ca6ed92e7ef425ababad7
--- /dev/null
+++ b/tasks/0039_599_39599874_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which video game holds the highest global sales rank between 1990 and 2000?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0039_599_39599874_qa_4/task.toml b/tasks/0039_599_39599874_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e58e473573b541ec92daff7eb77e1a1a835cbc4b
--- /dev/null
+++ b/tasks/0039_599_39599874_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0039_599_39599874_qa_4"
+description = "Which video game holds the highest global sales rank between 1990 and 2000?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/599/39599874.ipynb_qa_4"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Pokemon Red/Pokemon Blue"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Pokemon Red/Pokemon Blue"
+QUESTION = "Which video game holds the highest global sales rank between 1990 and 2000?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0039_655_39655291_qa_2/instruction.md b/tasks/0039_655_39655291_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ac7edd63e121182bc77f917be6e450de9f77ca5
--- /dev/null
+++ b/tasks/0039_655_39655291_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean value of the 'quality' target variable in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0039_655_39655291_qa_2/task.toml b/tasks/0039_655_39655291_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e27647c74dfdd1736e1bf4653ee2b4699de9e661
--- /dev/null
+++ b/tasks/0039_655_39655291_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0039_655_39655291_qa_2"
+description = "What is the mean value of the 'quality' target variable in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/655/39655291.ipynb_qa_2"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "5.636"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5.636"
+QUESTION = "What is the mean value of the 'quality' target variable in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0039_655_39655291_qa_4/instruction.md b/tasks/0039_655_39655291_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb59cefe4402b496af0e74add0cb6b0c64d4ec04
--- /dev/null
+++ b/tasks/0039_655_39655291_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many data points are present in the wine quality dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0039_655_39655291_qa_4/task.toml b/tasks/0039_655_39655291_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..54db89c1c20467d4f8e531fbbd4a4151cf5f92b5
--- /dev/null
+++ b/tasks/0039_655_39655291_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0039_655_39655291_qa_4"
+description = "How many data points are present in the wine quality dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/655/39655291.ipynb_qa_4"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "1599"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1599"
+QUESTION = "How many data points are present in the wine quality dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0039_742_39742099_qa_4/instruction.md b/tasks/0039_742_39742099_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..70f862d0de4ed1b725e2677e14a7e392e29e045e
--- /dev/null
+++ b/tasks/0039_742_39742099_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which U.S. region has the highest number of patients in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0039_742_39742099_qa_4/task.toml b/tasks/0039_742_39742099_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8235904ba50e67ca23dc1b607d14ab1ac4817ec0
--- /dev/null
+++ b/tasks/0039_742_39742099_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0039_742_39742099_qa_4"
+description = "Which U.S. region has the highest number of patients in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/742/39742099.ipynb_qa_4"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "Southeast"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Southeast"
+QUESTION = "Which U.S. region has the highest number of patients in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0039_742_39742099_qa_5/instruction.md b/tasks/0039_742_39742099_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1467b2550819f472b0d6405b34171ff96268ce95
--- /dev/null
+++ b/tasks/0039_742_39742099_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Is the overall multiple linear regression model statistically significant at the 0.05 significance level?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0039_742_39742099_qa_5/task.toml b/tasks/0039_742_39742099_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..412665d7bbe3860f06a90b048be25185616f8e81
--- /dev/null
+++ b/tasks/0039_742_39742099_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0039_742_39742099_qa_5"
+description = "Is the overall multiple linear regression model statistically significant at the 0.05 significance level?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/742/39742099.ipynb_qa_5"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Is the overall multiple linear regression model statistically significant at the 0.05 significance level?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0040_576_40576526_qa_2/instruction.md b/tasks/0040_576_40576526_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..86891dcbfee4ae2bc71c5da9256676f1b5cfb1fb
--- /dev/null
+++ b/tasks/0040_576_40576526_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- glass.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which glass type has the highest proportion of samples concentrated in a single k-means cluster?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0040_576_40576526_qa_2/task.toml b/tasks/0040_576_40576526_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..708b12152d5a0f56246f89172feba8e29b506510
--- /dev/null
+++ b/tasks/0040_576_40576526_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0040_576_40576526_qa_2"
+description = "Which glass type has the highest proportion of samples concentrated in a single k-means cluster?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/576/40576526.ipynb_qa_2"
+kaggle_dataset_name = "uciml/glass"
+gold_answer = "Type 7"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__glass"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/glass"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Type 7"
+QUESTION = "Which glass type has the highest proportion of samples concentrated in a single k-means cluster?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0040_717_40717045_qa_2/instruction.md b/tasks/0040_717_40717045_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..757a23411ee7a262d30ad15c6aca19dd626f9691
--- /dev/null
+++ b/tasks/0040_717_40717045_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which numerical feature has the highest chi-squared test score when analyzing its relationship with customer churn?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0040_717_40717045_qa_2/task.toml b/tasks/0040_717_40717045_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..97d28548521a4dce54606a6d02e5a999b40b82dc
--- /dev/null
+++ b/tasks/0040_717_40717045_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0040_717_40717045_qa_2"
+description = "Which numerical feature has the highest chi-squared test score when analyzing its relationship with customer churn?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/717/40717045.ipynb_qa_2"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "TotalCharges"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "TotalCharges"
+QUESTION = "Which numerical feature has the highest chi-squared test score when analyzing its relationship with customer churn?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0040_789_40789473_qa_3/instruction.md b/tasks/0040_789_40789473_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..dfcc8e214176fe86f93e6313f24b785ba03258cd
--- /dev/null
+++ b/tasks/0040_789_40789473_qa_3/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Test.csv
+- Train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many distinct item types are present in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0040_789_40789473_qa_3/task.toml b/tasks/0040_789_40789473_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..dc0e1c5793bd25266f8490f7de471b19cdc54373
--- /dev/null
+++ b/tasks/0040_789_40789473_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0040_789_40789473_qa_3"
+description = "How many distinct item types are present in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/789/40789473.ipynb_qa_3"
+kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data"
+gold_answer = "16"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "16"
+QUESTION = "How many distinct item types are present in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0040_789_40789473_qa_5/instruction.md b/tasks/0040_789_40789473_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae217bcdbcf770f5a80d07eb8761552349bcb6cd
--- /dev/null
+++ b/tasks/0040_789_40789473_qa_5/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Test.csv
+- Train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean 'Item_Weight' used to impute missing values in the 'Item_Weight' column?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0040_789_40789473_qa_5/task.toml b/tasks/0040_789_40789473_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..18eb93b646ffbce99878f537b7d541141b7367d3
--- /dev/null
+++ b/tasks/0040_789_40789473_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0040_789_40789473_qa_5"
+description = "What is the mean 'Item_Weight' used to impute missing values in the 'Item_Weight' column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/789/40789473.ipynb_qa_5"
+kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data"
+gold_answer = "12.857645"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "12.857645"
+QUESTION = "What is the mean 'Item_Weight' used to impute missing values in the 'Item_Weight' column?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0040_808_40808132_qa_5/instruction.md b/tasks/0040_808_40808132_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..934545039465dac457932aed5c4b60589415501d
--- /dev/null
+++ b/tasks/0040_808_40808132_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- glass.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which machine learning model achieved the highest median accuracy through k-fold cross-validation, and what was this median accuracy value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <model name>, <value> (comma-separated, label first, keep decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0040_808_40808132_qa_5/task.toml b/tasks/0040_808_40808132_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..267ce8a0b91c6f8f5c1b1966d4180bd8dec047ef
--- /dev/null
+++ b/tasks/0040_808_40808132_qa_5/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0040_808_40808132_qa_5"
+description = "Which machine learning model achieved the highest median accuracy through k-fold cross-validation, and what was this median accuracy value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/808/40808132.ipynb_qa_5"
+kaggle_dataset_name = "uciml/glass"
+gold_answer = "Decision trees (entropy-based) with median accuracy of 70%"
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__glass"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/glass"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Random Forest with median accuracy of 0.8095"
+QUESTION = "Which machine learning model achieved the highest median accuracy through k-fold cross-validation, and what was this median accuracy value?"
+REWARD_MODE = "flexible"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0040_843_40843458_qa_3/instruction.md b/tasks/0040_843_40843458_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5790e747b5b9789df157fc6d7920b276ee539ab1
--- /dev/null
+++ b/tasks/0040_843_40843458_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winemag-data-130k-v2.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest price recorded for a wine in Argentina?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0040_843_40843458_qa_3/task.toml b/tasks/0040_843_40843458_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6d1a33226470377a235107c3d8ed4e0de9bb195c
--- /dev/null
+++ b/tasks/0040_843_40843458_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0040_843_40843458_qa_3"
+description = "What is the highest price recorded for a wine in Argentina?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/843/40843458.ipynb_qa_3"
+kaggle_dataset_name = "zynicide/wine-reviews"
+gold_answer = "230"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "zynicide__wine-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zynicide/wine-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "230"
+QUESTION = "What is the highest price recorded for a wine in Argentina?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0040_929_40929685_qa_2/instruction.md b/tasks/0040_929_40929685_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8470e8baeba8718f3c262c4d8e9eb6c52b3da426
--- /dev/null
+++ b/tasks/0040_929_40929685_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which ocean proximity category has the highest frequency of entries in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0040_929_40929685_qa_2/task.toml b/tasks/0040_929_40929685_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7ecc8b929e914c3696962b8d1be46b8cd1ec828f
--- /dev/null
+++ b/tasks/0040_929_40929685_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0040_929_40929685_qa_2"
+description = "Which ocean proximity category has the highest frequency of entries in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/929/40929685.ipynb_qa_2"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "<1H OCEAN"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "<1H OCEAN"
+QUESTION = "Which ocean proximity category has the highest frequency of entries in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0040_981_40981860_qa_1/instruction.md b/tasks/0040_981_40981860_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb047461c06610689e32db9b1fc094fb4040ea66
--- /dev/null
+++ b/tasks/0040_981_40981860_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- tmdb_5000_credits.csv
+- tmdb_5000_movies.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many movies are recommended when using the content-based filtering approach for the movie 'Spectre'?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0040_981_40981860_qa_1/task.toml b/tasks/0040_981_40981860_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..aa4bfcd572312064ab3e8a0a1d10d140e708a0a2
--- /dev/null
+++ b/tasks/0040_981_40981860_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0040_981_40981860_qa_1"
+description = "How many movies are recommended when using the content-based filtering approach for the movie 'Spectre'?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/981/40981860.ipynb_qa_1"
+kaggle_dataset_name = "tmdb/tmdb-movie-metadata"
+gold_answer = "10"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "tmdb__tmdb-movie-metadata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "10"
+QUESTION = "How many movies are recommended when using the content-based filtering approach for the movie 'Spectre'?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0041_143_41143507_qa_1/instruction.md b/tasks/0041_143_41143507_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bcc38a6ecf69d360c578aa6cec26e5b85606d51f
--- /dev/null
+++ b/tasks/0041_143_41143507_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- adult.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest permutation importance in the trained model based on the test set evaluation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_143_41143507_qa_1/task.toml b/tasks/0041_143_41143507_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d50aca7e591acfb516cb95818bdeca12c8d60872
--- /dev/null
+++ b/tasks/0041_143_41143507_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0041_143_41143507_qa_1"
+description = "Which feature has the highest permutation importance in the trained model based on the test set evaluation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/143/41143507.ipynb_qa_1"
+kaggle_dataset_name = "uciml/adult-census-income"
+gold_answer = "capital.gain"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__adult-census-income"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/adult-census-income"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "capital.gain"
+QUESTION = "Which feature has the highest permutation importance in the trained model based on the test set evaluation?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0041_145_41145764_qa_2/instruction.md b/tasks/0041_145_41145764_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1a125b68b070195b6b83cc9fca170f7eb13915e2
--- /dev/null
+++ b/tasks/0041_145_41145764_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between weight and BMI in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_145_41145764_qa_2/task.toml b/tasks/0041_145_41145764_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2542010babe9690a40060e22c9526b30fcda6f3d
--- /dev/null
+++ b/tasks/0041_145_41145764_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0041_145_41145764_qa_2"
+description = "What is the correlation coefficient between weight and BMI in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/145/41145764.ipynb_qa_2"
+kaggle_dataset_name = "tmcketterick/heights-and-weights"
+gold_answer = "-0.885171"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "tmcketterick__heights-and-weights"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tmcketterick/heights-and-weights"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-0.885171"
+QUESTION = "What is the correlation coefficient between weight and BMI in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0041_193_41193082_qa_3/instruction.md b/tasks/0041_193_41193082_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f18c284100bb96e769273cf2af13dba21b2ec119
--- /dev/null
+++ b/tasks/0041_193_41193082_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature exhibits the strongest positive correlation with 'compactness_worst' in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_193_41193082_qa_3/task.toml b/tasks/0041_193_41193082_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a9ed3f49c6362f9c095b9557b4319ba8b6dcf6e6
--- /dev/null
+++ b/tasks/0041_193_41193082_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0041_193_41193082_qa_3"
+description = "Which feature exhibits the strongest positive correlation with 'compactness_worst' in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/193/41193082.ipynb_qa_3"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "concavity_worst"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "concavity_worst"
+QUESTION = "Which feature exhibits the strongest positive correlation with 'compactness_worst' in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0041_193_41193541_qa_5/instruction.md b/tasks/0041_193_41193541_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9564ae7c09b1588f4bfdae87008f06ada0c9290a
--- /dev/null
+++ b/tasks/0041_193_41193541_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- auto-mpg.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many unique categories were present in the 'cylinders' feature prior to one-hot encoding?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_193_41193541_qa_5/task.toml b/tasks/0041_193_41193541_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..259a1a61ad24bd4bcc7b0a6ee4e658d2111cd217
--- /dev/null
+++ b/tasks/0041_193_41193541_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0041_193_41193541_qa_5"
+description = "How many unique categories were present in the 'cylinders' feature prior to one-hot encoding?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/193/41193541.ipynb_qa_5"
+kaggle_dataset_name = "uciml/autompg-dataset"
+gold_answer = "5"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__autompg-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/autompg-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5"
+QUESTION = "How many unique categories were present in the 'cylinders' feature prior to one-hot encoding?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0041_198_41198482_qa_1/instruction.md b/tasks/0041_198_41198482_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a8514a3c178629308ca4c55dae0f19bf0e6d2229
--- /dev/null
+++ b/tasks/0041_198_41198482_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- haberman.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the percentage of patients in the dataset who survived for five years or more?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_198_41198482_qa_1/task.toml b/tasks/0041_198_41198482_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e9ad8f7fc902b35c69e1c3547995c65c71982625
--- /dev/null
+++ b/tasks/0041_198_41198482_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0041_198_41198482_qa_1"
+description = "What is the percentage of patients in the dataset who survived for five years or more?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/198/41198482.ipynb_qa_1"
+kaggle_dataset_name = "gilsousa/habermans-survival-data-set"
+gold_answer = "73.53"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gilsousa__habermans-survival-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "73.53"
+QUESTION = "What is the percentage of patients in the dataset who survived for five years or more?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0041_253_41253749_qa_5/instruction.md b/tasks/0041_253_41253749_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cfc79215708b23f2ce3aa273b8422db691fc88dc
--- /dev/null
+++ b/tasks/0041_253_41253749_qa_5/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- X.npy
+- Y.npy
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the minimum number of images for any digit after reorganizing the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_253_41253749_qa_5/task.toml b/tasks/0041_253_41253749_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a12e5c8a9fddec9b9bbba076b40a9f018501bab4
--- /dev/null
+++ b/tasks/0041_253_41253749_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0041_253_41253749_qa_5"
+description = "What is the minimum number of images for any digit after reorganizing the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/253/41253749.ipynb_qa_5"
+kaggle_dataset_name = "ardamavi/sign-language-digits-dataset"
+gold_answer = "204"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ardamavi__sign-language-digits-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ardamavi/sign-language-digits-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "204"
+QUESTION = "What is the minimum number of images for any digit after reorganizing the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0041_268_41268576_qa_1/instruction.md b/tasks/0041_268_41268576_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa4562ffb46666e628c8877544512d8097d68ef6
--- /dev/null
+++ b/tasks/0041_268_41268576_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- movies.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of all movies in the dataset are produced by the top 10 countries with the highest number of released films?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_268_41268576_qa_1/task.toml b/tasks/0041_268_41268576_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..efef024a57a1ccd41769ac1a513c7d650c344f0f
--- /dev/null
+++ b/tasks/0041_268_41268576_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0041_268_41268576_qa_1"
+description = "What percentage of all movies in the dataset are produced by the top 10 countries with the highest number of released films?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/268/41268576.ipynb_qa_1"
+kaggle_dataset_name = "danielgrijalvas/movies"
+gold_answer = "94.7"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "danielgrijalvas__movies"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "danielgrijalvas/movies"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "94.7"
+QUESTION = "What percentage of all movies in the dataset are produced by the top 10 countries with the highest number of released films?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0041_600_41600293_qa_2/instruction.md b/tasks/0041_600_41600293_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fe1a9faf83d35c7dafc73cd47946eb1f3aeea348
--- /dev/null
+++ b/tasks/0041_600_41600293_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the original ratio of churned to non-churned customers in the dataset before upsampling?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_600_41600293_qa_2/task.toml b/tasks/0041_600_41600293_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1569aafb486989e8124383f3d9310a2d45c867e7
--- /dev/null
+++ b/tasks/0041_600_41600293_qa_2/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0041_600_41600293_qa_2"
+description = "What was the original ratio of churned to non-churned customers in the dataset before upsampling?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/600/41600293.ipynb_qa_2"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "2:5"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1869:5174"
+QUESTION = "What was the original ratio of churned to non-churned customers in the dataset before upsampling?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0041_714_41714800_qa_3/instruction.md b/tasks/0041_714_41714800_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..255dbf2c4dc71287656ab4f9eba2474858625d90
--- /dev/null
+++ b/tasks/0041_714_41714800_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which department has the highest number of employees in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0041_714_41714800_qa_3/task.toml b/tasks/0041_714_41714800_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..19c95a141c9498bc604138a3462f8ac7f670de43
--- /dev/null
+++ b/tasks/0041_714_41714800_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0041_714_41714800_qa_3"
+description = "Which department has the highest number of employees in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/714/41714800.ipynb_qa_3"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "Research & Development"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Research & Development"
+QUESTION = "Which department has the highest number of employees in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0042_170_42170738_qa_2/instruction.md b/tasks/0042_170_42170738_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f1ded233c996a82e3640206a942f4c0ee3291d17
--- /dev/null
+++ b/tasks/0042_170_42170738_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest edibility percentage observed for any specific mushroom cap color category in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0042_170_42170738_qa_2/task.toml b/tasks/0042_170_42170738_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..81be980099de32597651fc4bb46732cfd6817f9a
--- /dev/null
+++ b/tasks/0042_170_42170738_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0042_170_42170738_qa_2"
+description = "What is the highest edibility percentage observed for any specific mushroom cap color category in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0042/170/42170738.ipynb_qa_2"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "100"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "100"
+QUESTION = "What is the highest edibility percentage observed for any specific mushroom cap color category in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0042_383_42383310_qa_2/instruction.md b/tasks/0042_383_42383310_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..943e22c3a4d885d64c232629c73dfbdb208e8744
--- /dev/null
+++ b/tasks/0042_383_42383310_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- car_ad.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the data type of the 'engV' column after completing the data cleaning process?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0042_383_42383310_qa_2/task.toml b/tasks/0042_383_42383310_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f6a3a6c7da953563be533690fe54237fa2a2e576
--- /dev/null
+++ b/tasks/0042_383_42383310_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0042_383_42383310_qa_2"
+description = "What is the data type of the 'engV' column after completing the data cleaning process?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0042/383/42383310.ipynb_qa_2"
+kaggle_dataset_name = "antfarol/car-sale-advertisements"
+gold_answer = "float64"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "antfarol__car-sale-advertisements"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "antfarol/car-sale-advertisements"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "float64"
+QUESTION = "What is the data type of the 'engV' column after completing the data cleaning process?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0042_414_42414264_qa_2/instruction.md b/tasks/0042_414_42414264_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fc70ea39be6d85eb5b70c143628781d6aa625abd
--- /dev/null
+++ b/tasks/0042_414_42414264_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of patients in the dataset have diabetes based on the class distribution analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0042_414_42414264_qa_2/task.toml b/tasks/0042_414_42414264_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b82d5b36b534bcdd527d1962722f0e65a6f6aa60
--- /dev/null
+++ b/tasks/0042_414_42414264_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0042_414_42414264_qa_2"
+description = "What percentage of patients in the dataset have diabetes based on the class distribution analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0042/414/42414264.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "34.895833"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "34.895833"
+QUESTION = "What percentage of patients in the dataset have diabetes based on the class distribution analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0042_569_42569940_qa_1/instruction.md b/tasks/0042_569_42569940_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bb37d1afdd2af7618495aec35ba3061974fcefd1
--- /dev/null
+++ b/tasks/0042_569_42569940_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- credit_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of missing values in the 'Months since last delinquent' column were replaced with zero based on the credit score analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0042_569_42569940_qa_1/task.toml b/tasks/0042_569_42569940_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..59e8845ac2a387f5368e8f2d6135e92d3cd8f3e7
--- /dev/null
+++ b/tasks/0042_569_42569940_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0042_569_42569940_qa_1"
+description = "What percentage of missing values in the 'Months since last delinquent' column were replaced with zero based on the credit score analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0042/569/42569940.ipynb_qa_1"
+kaggle_dataset_name = "zaurbegiev/my-dataset"
+gold_answer = "53.14"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "zaurbegiev__my-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zaurbegiev/my-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "53.14"
+QUESTION = "What percentage of missing values in the 'Months since last delinquent' column were replaced with zero based on the credit score analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0042_903_42903883_qa_1/instruction.md b/tasks/0042_903_42903883_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..74143e95e6de210e09b8653dced25bd21758325b
--- /dev/null
+++ b/tasks/0042_903_42903883_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- bigml_59c28831336c6604c800002a.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Какой процент клиентов в наборе данных относится к лояльным (без оттока)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0042_903_42903883_qa_1/task.toml b/tasks/0042_903_42903883_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c439dec09481d8fad6cf1ee1dc6ab99554f28bcc
--- /dev/null
+++ b/tasks/0042_903_42903883_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0042_903_42903883_qa_1"
+description = "Какой процент клиентов в наборе данных относится к лояльным (без оттока)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0042/903/42903883.ipynb_qa_1"
+kaggle_dataset_name = "becksddf/churn-in-telecoms-dataset"
+gold_answer = "85.5086"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "becksddf__churn-in-telecoms-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "becksddf/churn-in-telecoms-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "85.5086"
+QUESTION = "Какой процент клиентов в наборе данных относится к лояльным (без оттока)?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_029_43029106_qa_1/instruction.md b/tasks/0043_029_43029106_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2c5ccc831f327f9bc2ac328c3d1699f133eb7239
--- /dev/null
+++ b/tasks/0043_029_43029106_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Social_Network_Ads.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the count of users who did not make a purchase versus those who did in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_029_43029106_qa_1/task.toml b/tasks/0043_029_43029106_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2257599c339f9e6110ab23e0cc8b72e93293b140
--- /dev/null
+++ b/tasks/0043_029_43029106_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0043_029_43029106_qa_1"
+description = "What is the count of users who did not make a purchase versus those who did in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/029/43029106.ipynb_qa_1"
+kaggle_dataset_name = "rakeshrau/social-network-ads"
+gold_answer = "0: 257, 1: 143"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rakeshrau__social-network-ads"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rakeshrau/social-network-ads"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0: 257, 1: 143"
+QUESTION = "What is the count of users who did not make a purchase versus those who did in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_124_43124508_qa_1/instruction.md b/tasks/0043_124_43124508_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..43d27eed930293d025f11aa4b70de176bbf39d2c
--- /dev/null
+++ b/tasks/0043_124_43124508_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest importance in predicting mushroom edibility according to the Decision Tree model's feature importance analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_124_43124508_qa_1/task.toml b/tasks/0043_124_43124508_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8748de6edc837fe143bd8a841c6c78a1be26bf83
--- /dev/null
+++ b/tasks/0043_124_43124508_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0043_124_43124508_qa_1"
+description = "Which feature has the highest importance in predicting mushroom edibility according to the Decision Tree model's feature importance analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/124/43124508.ipynb_qa_1"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "gill-color"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "gill-color"
+QUESTION = "Which feature has the highest importance in predicting mushroom edibility according to the Decision Tree model's feature importance analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_305_43305320_qa_4/instruction.md b/tasks/0043_305_43305320_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e52cded11822274d05c35eed2774e9ddd41c499
--- /dev/null
+++ b/tasks/0043_305_43305320_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- HN_posts_year_to_Sep_26_2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average number of votes per Show HN post in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_305_43305320_qa_4/task.toml b/tasks/0043_305_43305320_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9780f80f7be48e54c34e583270dad474f4aef19a
--- /dev/null
+++ b/tasks/0043_305_43305320_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0043_305_43305320_qa_4"
+description = "What is the average number of votes per Show HN post in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/305/43305320.ipynb_qa_4"
+kaggle_dataset_name = "hacker-news/hacker-news-posts"
+gold_answer = "14.84"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "hacker-news__hacker-news-posts"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "hacker-news/hacker-news-posts"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "14.84"
+QUESTION = "What is the average number of votes per Show HN post in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_313_43313326_qa_2/instruction.md b/tasks/0043_313_43313326_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7b081bb2acbaadd296aa37209a96e6aaa1f8697c
--- /dev/null
+++ b/tasks/0043_313_43313326_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the percentage of diabetic individuals (Outcome=1) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_313_43313326_qa_2/task.toml b/tasks/0043_313_43313326_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ee92ab94f5337c1bd113113d5875e8b914a4bbc3
--- /dev/null
+++ b/tasks/0043_313_43313326_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0043_313_43313326_qa_2"
+description = "What is the percentage of diabetic individuals (Outcome=1) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/313/43313326.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "34.8958"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "34.8958"
+QUESTION = "What is the percentage of diabetic individuals (Outcome=1) in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_313_43313326_qa_5/instruction.md b/tasks/0043_313_43313326_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1961a5f9b2c913fd1a8a0ba2bcb70109a3b915d5
--- /dev/null
+++ b/tasks/0043_313_43313326_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature is identified as most important by the Random Forest model for predicting diabetes outcome?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_313_43313326_qa_5/task.toml b/tasks/0043_313_43313326_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d6ae895e7b8643cfb43038538b655c22229b4f3a
--- /dev/null
+++ b/tasks/0043_313_43313326_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0043_313_43313326_qa_5"
+description = "Which feature is identified as most important by the Random Forest model for predicting diabetes outcome?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/313/43313326.ipynb_qa_5"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "Which feature is identified as most important by the Random Forest model for predicting diabetes outcome?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_338_43338909_qa_1/instruction.md b/tasks/0043_338_43338909_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..512e6af992abc3292d52f385ccea98e401c2f3a2
--- /dev/null
+++ b/tasks/0043_338_43338909_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum Lift value achieved in any decile of predicted probabilities according to the model's performance analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_338_43338909_qa_1/task.toml b/tasks/0043_338_43338909_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2a003a8dafa106d2315a824ba3aa5a4b54a77478
--- /dev/null
+++ b/tasks/0043_338_43338909_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0043_338_43338909_qa_1"
+description = "What is the maximum Lift value achieved in any decile of predicted probabilities according to the model's performance analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/338/43338909.ipynb_qa_1"
+kaggle_dataset_name = "kabure/german-credit-data-with-risk"
+gold_answer = "2.09"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kabure__german-credit-data-with-risk"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kabure/german-credit-data-with-risk"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2.09"
+QUESTION = "What is the maximum Lift value achieved in any decile of predicted probabilities according to the model's performance analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_348_43348851_qa_1/instruction.md b/tasks/0043_348_43348851_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5569c4636d0bcf34c2a929f4c3a3bda5ce9d227b
--- /dev/null
+++ b/tasks/0043_348_43348851_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many dummy variables were generated from the original categorical features after excluding Vehicle_Age which was transformed to numeric?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_348_43348851_qa_1/task.toml b/tasks/0043_348_43348851_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a132b4e9f456dd844ee666dedd09e8b72501f1fc
--- /dev/null
+++ b/tasks/0043_348_43348851_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0043_348_43348851_qa_1"
+description = "How many dummy variables were generated from the original categorical features after excluding Vehicle_Age which was transformed to numeric?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/348/43348851.ipynb_qa_1"
+kaggle_dataset_name = "apollo2506/flowers-recognition-dataset"
+gold_answer = "4"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "apollo2506__flowers-recognition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "apollo2506/flowers-recognition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4"
+QUESTION = "How many dummy variables were generated from the original categorical features after excluding Vehicle_Age which was transformed to numeric?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_720_43720895_qa_2/instruction.md b/tasks/0043_720_43720895_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6837705c49529da757762a51ef716cd5caf1f2e8
--- /dev/null
+++ b/tasks/0043_720_43720895_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the churn rate for customers without a partner?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_720_43720895_qa_2/task.toml b/tasks/0043_720_43720895_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f77a1943c022d326d2d0243bb733cd4f218085e7
--- /dev/null
+++ b/tasks/0043_720_43720895_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0043_720_43720895_qa_2"
+description = "What is the churn rate for customers without a partner?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/720/43720895.ipynb_qa_2"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "32.96"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "32.96"
+QUESTION = "What is the churn rate for customers without a partner?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_783_43783786_qa_3/instruction.md b/tasks/0043_783_43783786_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f390c565077aac5707c33a5cbdea478397823f11
--- /dev/null
+++ b/tasks/0043_783_43783786_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- titanic_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After data preprocessing, how many missing values were imputed in the 'Age' column using class-specific average values?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_783_43783786_qa_3/task.toml b/tasks/0043_783_43783786_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..79737d2fbbcf0c23b2adc2a54a02abd6f188c6fb
--- /dev/null
+++ b/tasks/0043_783_43783786_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0043_783_43783786_qa_3"
+description = "After data preprocessing, how many missing values were imputed in the 'Age' column using class-specific average values?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/783/43783786.ipynb_qa_3"
+kaggle_dataset_name = "tedllh/titanic-train"
+gold_answer = "177"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "tedllh__titanic-train"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tedllh/titanic-train"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "177"
+QUESTION = "After data preprocessing, how many missing values were imputed in the 'Age' column using class-specific average values?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0044_141_44141679_qa_3/instruction.md b/tasks/0044_141_44141679_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..892e746bdb95bb24282ed92e4fc0ead9a87633c5
--- /dev/null
+++ b/tasks/0044_141_44141679_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After imputing missing values using median imputation stratified by diabetes status, what is the median Glucose level for non-diabetic patients (Outcome = 0)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0044_141_44141679_qa_3/task.toml b/tasks/0044_141_44141679_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8a9c32404bd18e2edd3d9cd2d681ee50bf52d8ef
--- /dev/null
+++ b/tasks/0044_141_44141679_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0044_141_44141679_qa_3"
+description = "After imputing missing values using median imputation stratified by diabetes status, what is the median Glucose level for non-diabetic patients (Outcome = 0)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0044/141/44141679.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "107"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "107"
+QUESTION = "After imputing missing values using median imputation stratified by diabetes status, what is the median Glucose level for non-diabetic patients (Outcome = 0)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0045_056_45056822_qa_5/instruction.md b/tasks/0045_056_45056822_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..333c6a44b10e946d3496b6189e7e9d569a9d0c41
--- /dev/null
+++ b/tasks/0045_056_45056822_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- games.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average rating of White players when they win a game compared to when they lose a game?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of two numbers, in the order given: <average_rating_when_win>, <average_rating_when_lose>.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0045_056_45056822_qa_5/task.toml b/tasks/0045_056_45056822_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..84f8e88af4fc178330776c310eff2f79f00b12d4
--- /dev/null
+++ b/tasks/0045_056_45056822_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0045_056_45056822_qa_5"
+description = "What is the average rating of White players when they win a game compared to when they lose a game?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0045/056/45056822.ipynb_qa_5"
+kaggle_dataset_name = "datasnaek/chess"
+gold_answer = "1634.18, 1549.25"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "datasnaek__chess"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "datasnaek/chess"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1634.18, 1549.25"
+QUESTION = "What is the average rating of White players when they win a game compared to when they lose a game?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0045_100_45100270_qa_4/instruction.md b/tasks/0045_100_45100270_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..26ff979512ae6015a806ebf577dfa8dd19e06572
--- /dev/null
+++ b/tasks/0045_100_45100270_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the absolute difference in validation accuracy between the best Decision Tree model (0.59375) and the best Random Forest model (0.6625)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0045_100_45100270_qa_4/task.toml b/tasks/0045_100_45100270_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3b1bb50ad827f75217b44801dd49434be9290d78
--- /dev/null
+++ b/tasks/0045_100_45100270_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0045_100_45100270_qa_4"
+description = "What is the absolute difference in validation accuracy between the best Decision Tree model (0.59375) and the best Random Forest model (0.6625)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0045/100/45100270.ipynb_qa_4"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "0.06875"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.06875"
+QUESTION = "What is the absolute difference in validation accuracy between the best Decision Tree model (0.59375) and the best Random Forest model (0.6625)?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0045_136_45136728_qa_1/instruction.md b/tasks/0045_136_45136728_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3135c71c52142b1d1f1486d206ac415e9ddfcae4
--- /dev/null
+++ b/tasks/0045_136_45136728_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of employees in the dataset attrited (Attrition = Yes)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0045_136_45136728_qa_1/task.toml b/tasks/0045_136_45136728_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b6478d769ca411c3492b7b6d803578ae783cce14
--- /dev/null
+++ b/tasks/0045_136_45136728_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0045_136_45136728_qa_1"
+description = "What percentage of employees in the dataset attrited (Attrition = Yes)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0045/136/45136728.ipynb_qa_1"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "16.1"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "16.1"
+QUESTION = "What percentage of employees in the dataset attrited (Attrition = Yes)?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0045_738_45738362_qa_2/instruction.md b/tasks/0045_738_45738362_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fa4d4cefde06aa6d3d11fd3d0cf5721ef8e53135
--- /dev/null
+++ b/tasks/0045_738_45738362_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of unique years in the dataset before removing 2017 and 2020?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0045_738_45738362_qa_2/task.toml b/tasks/0045_738_45738362_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..856bcc604e6b0924c32740e467e5ed01dda7cdd5
--- /dev/null
+++ b/tasks/0045_738_45738362_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0045_738_45738362_qa_2"
+description = "What is the total number of unique years in the dataset before removing 2017 and 2020?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0045/738/45738362.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "39"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "39"
+QUESTION = "What is the total number of unique years in the dataset before removing 2017 and 2020?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0045_738_45738362_qa_4/instruction.md b/tasks/0045_738_45738362_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..75e4d621da9f68f07bb905e62b0710d55ee1b969
--- /dev/null
+++ b/tasks/0045_738_45738362_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many publishers are included in the cumulative sales analysis for the top 30 publishers?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0045_738_45738362_qa_4/task.toml b/tasks/0045_738_45738362_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9c34b7ddeb1a894afafabbfb3bf33e6e8579e64d
--- /dev/null
+++ b/tasks/0045_738_45738362_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0045_738_45738362_qa_4"
+description = "How many publishers are included in the cumulative sales analysis for the top 30 publishers?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0045/738/45738362.ipynb_qa_4"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "30"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "30"
+QUESTION = "How many publishers are included in the cumulative sales analysis for the top 30 publishers?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0046_035_46035466_qa_2/instruction.md b/tasks/0046_035_46035466_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..23531d761c75b007b28918e0472767775f1e0b91
--- /dev/null
+++ b/tasks/0046_035_46035466_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many data points are present in each species category of the original dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0046_035_46035466_qa_2/task.toml b/tasks/0046_035_46035466_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b7c0df18510db635c3e45343561b7d1d39eb6626
--- /dev/null
+++ b/tasks/0046_035_46035466_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0046_035_46035466_qa_2"
+description = "How many data points are present in each species category of the original dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0046/035/46035466.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "50"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "50"
+QUESTION = "How many data points are present in each species category of the original dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0046_115_46115058_qa_5/instruction.md b/tasks/0046_115_46115058_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..71b4ae25903f7d9e957e13a8f88b6f3bf541ece0
--- /dev/null
+++ b/tasks/0046_115_46115058_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the 95% confidence interval for the cross-validated accuracy of the final model using RFE feature selection?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated pair: <lower>, <upper> (plain numbers, keep four decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0046_115_46115058_qa_5/task.toml b/tasks/0046_115_46115058_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..19b9c121bd4b65a0040f81246e5141163070981c
--- /dev/null
+++ b/tasks/0046_115_46115058_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0046_115_46115058_qa_5"
+description = "What is the 95% confidence interval for the cross-validated accuracy of the final model using RFE feature selection?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0046/115/46115058.ipynb_qa_5"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "0.7264, 0.8075"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.7264, 0.8075"
+QUESTION = "What is the 95% confidence interval for the cross-validated accuracy of the final model using RFE feature selection?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0046_597_46597030_qa_1/instruction.md b/tasks/0046_597_46597030_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..db2a88ca85937512efdbbfbfaaf1dbf737e51227
--- /dev/null
+++ b/tasks/0046_597_46597030_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which passenger class (Pclass) had the highest survival rate based on the dataset analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0046_597_46597030_qa_1/task.toml b/tasks/0046_597_46597030_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..80726f45446d34b7e13171b381dbf65504bd24ab
--- /dev/null
+++ b/tasks/0046_597_46597030_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0046_597_46597030_qa_1"
+description = "Which passenger class (Pclass) had the highest survival rate based on the dataset analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0046/597/46597030.ipynb_qa_1"
+kaggle_dataset_name = "rashigoel/titanic-machine-learning-from-disaster"
+gold_answer = "1"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rashigoel__titanic-machine-learning-from-disaster"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rashigoel/titanic-machine-learning-from-disaster"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1"
+QUESTION = "Which passenger class (Pclass) had the highest survival rate based on the dataset analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0046_933_46933248_qa_5/instruction.md b/tasks/0046_933_46933248_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..997617812f9977274845d7dbb1608b1dabe26df4
--- /dev/null
+++ b/tasks/0046_933_46933248_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between median income and median house value from the correlation matrix visualization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0046_933_46933248_qa_5/task.toml b/tasks/0046_933_46933248_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ad25121cca3921b50fc1779f7f9f236e49215645
--- /dev/null
+++ b/tasks/0046_933_46933248_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0046_933_46933248_qa_5"
+description = "What is the correlation coefficient between median income and median house value from the correlation matrix visualization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0046/933/46933248.ipynb_qa_5"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "0.687"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.687"
+QUESTION = "What is the correlation coefficient between median income and median house value from the correlation matrix visualization?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0047_367_47367333_qa_4/instruction.md b/tasks/0047_367_47367333_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..024b56004d4af0726fa7328c42a2c201bdf5cfbc
--- /dev/null
+++ b/tasks/0047_367_47367333_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which mushroom characteristic had the highest number of unique categories after label encoding?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0047_367_47367333_qa_4/task.toml b/tasks/0047_367_47367333_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5cb5120c10fe5ea7282e9da26cdd3836c7ca791b
--- /dev/null
+++ b/tasks/0047_367_47367333_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0047_367_47367333_qa_4"
+description = "Which mushroom characteristic had the highest number of unique categories after label encoding?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0047/367/47367333.ipynb_qa_4"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "gill-color"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "gill-color"
+QUESTION = "Which mushroom characteristic had the highest number of unique categories after label encoding?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0047_507_47507147_qa_5/instruction.md b/tasks/0047_507_47507147_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d128bbe3e0cf6c3ce7ff804a99324558deb8941b
--- /dev/null
+++ b/tasks/0047_507_47507147_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which payment method has the highest churn rate according to the analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0047_507_47507147_qa_5/task.toml b/tasks/0047_507_47507147_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3f5118cda7e38ccd600b722b2edd8db0260636f5
--- /dev/null
+++ b/tasks/0047_507_47507147_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0047_507_47507147_qa_5"
+description = "Which payment method has the highest churn rate according to the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0047/507/47507147.ipynb_qa_5"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "Electronic check"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Electronic check"
+QUESTION = "Which payment method has the highest churn rate according to the analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0047_560_47560034_qa_5/instruction.md b/tasks/0047_560_47560034_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c4ef43ab591390a6dee7f9b3f29f45fb7e9f194a
--- /dev/null
+++ b/tasks/0047_560_47560034_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- IMDB-Movie-Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which genre had the highest percentage representation in 2016 compared to other genres that year?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0047_560_47560034_qa_5/task.toml b/tasks/0047_560_47560034_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..dbdd540120efcd40bcd61c2120c24a44993b8540
--- /dev/null
+++ b/tasks/0047_560_47560034_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0047_560_47560034_qa_5"
+description = "Which genre had the highest percentage representation in 2016 compared to other genres that year?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0047/560/47560034.ipynb_qa_5"
+kaggle_dataset_name = "PromptCloudHQ/imdb-data"
+gold_answer = "Drama"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "PromptCloudHQ__imdb-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "PromptCloudHQ/imdb-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Drama"
+QUESTION = "Which genre had the highest percentage representation in 2016 compared to other genres that year?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0047_667_47667613_qa_5/instruction.md b/tasks/0047_667_47667613_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7345abca2a292fe7cda1638ad19ba7c8c47efb83
--- /dev/null
+++ b/tasks/0047_667_47667613_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Does the t-SNE visualization show better class separation compared to PCA based on the analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0047_667_47667613_qa_5/task.toml b/tasks/0047_667_47667613_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9feb7a81c30409986a97987d0191875a92ee6061
--- /dev/null
+++ b/tasks/0047_667_47667613_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0047_667_47667613_qa_5"
+description = "Does the t-SNE visualization show better class separation compared to PCA based on the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0047/667/47667613.ipynb_qa_5"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Does the t-SNE visualization show better class separation compared to PCA based on the analysis?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0047_766_47766276_qa_2/instruction.md b/tasks/0047_766_47766276_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c9058117302961b880627c0b3d8ef72b5a7d5c7a
--- /dev/null
+++ b/tasks/0047_766_47766276_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum number of people recorded on weekends (is_weekend=1)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0047_766_47766276_qa_2/task.toml b/tasks/0047_766_47766276_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e5324479835288228f2811d4721fe094e4d1367b
--- /dev/null
+++ b/tasks/0047_766_47766276_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0047_766_47766276_qa_2"
+description = "What is the maximum number of people recorded on weekends (is_weekend=1)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0047/766/47766276.ipynb_qa_2"
+kaggle_dataset_name = "nsrose7224/crowdedness-at-the-campus-gym"
+gold_answer = "102"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "nsrose7224__crowdedness-at-the-campus-gym"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "nsrose7224/crowdedness-at-the-campus-gym"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "102"
+QUESTION = "What is the maximum number of people recorded on weekends (is_weekend=1)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0047_862_47862196_qa_2/instruction.md b/tasks/0047_862_47862196_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..42dfad05ced757b961a62dd9b74537b80be7af60
--- /dev/null
+++ b/tasks/0047_862_47862196_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of the original dataset consists of malignant cancer cases (diagnosis = 'M') before any data splitting or preprocessing?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0047_862_47862196_qa_2/task.toml b/tasks/0047_862_47862196_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6a0bb5f4b40d54ce1458d0886c3da2a43651320f
--- /dev/null
+++ b/tasks/0047_862_47862196_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0047_862_47862196_qa_2"
+description = "What percentage of the original dataset consists of malignant cancer cases (diagnosis = 'M') before any data splitting or preprocessing?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0047/862/47862196.ipynb_qa_2"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "37.26"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "37.26"
+QUESTION = "What percentage of the original dataset consists of malignant cancer cases (diagnosis = 'M') before any data splitting or preprocessing?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0048_022_48022242_qa_3/instruction.md b/tasks/0048_022_48022242_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b26d4cdb4401f2cc635571889c33c4e3eb85a55e
--- /dev/null
+++ b/tasks/0048_022_48022242_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the number of samples allocated to the test set after splitting the data with a 20% test size?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0048_022_48022242_qa_3/task.toml b/tasks/0048_022_48022242_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bf85ebea54305b0bc4258e4c73eaf653ed66637b
--- /dev/null
+++ b/tasks/0048_022_48022242_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0048_022_48022242_qa_3"
+description = "What is the number of samples allocated to the test set after splitting the data with a 20% test size?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0048/022/48022242.ipynb_qa_3"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "1115"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1115"
+QUESTION = "What is the number of samples allocated to the test set after splitting the data with a 20% test size?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0048_022_48022242_qa_4/instruction.md b/tasks/0048_022_48022242_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5a23ea5f072715a1816aaf539b9dcbcc01c891bf
--- /dev/null
+++ b/tasks/0048_022_48022242_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the number of samples allocated to the training set after splitting the data with an 80% training size?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0048_022_48022242_qa_4/task.toml b/tasks/0048_022_48022242_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6086e65d4f580b190c325d27ce33fe95812ea19f
--- /dev/null
+++ b/tasks/0048_022_48022242_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0048_022_48022242_qa_4"
+description = "What is the number of samples allocated to the training set after splitting the data with an 80% training size?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0048/022/48022242.ipynb_qa_4"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "4457"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4457"
+QUESTION = "What is the number of samples allocated to the training set after splitting the data with an 80% training size?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0048_518_48518667_qa_4/instruction.md b/tasks/0048_518_48518667_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2a9d75d2564b1ba5f3877f599f539e3b71bc3e94
--- /dev/null
+++ b/tasks/0048_518_48518667_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Fleet Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which aircraft type is most commonly used among the selected large aircraft categories (A380, A330, A340, 747, 777, 787) across all airlines in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0048_518_48518667_qa_4/task.toml b/tasks/0048_518_48518667_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..05a7279c5442b88240ffc462f0f28929893346c8
--- /dev/null
+++ b/tasks/0048_518_48518667_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0048_518_48518667_qa_4"
+description = "Which aircraft type is most commonly used among the selected large aircraft categories (A380, A330, A340, 747, 777, 787) across all airlines in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0048/518/48518667.ipynb_qa_4"
+kaggle_dataset_name = "traceyvanp/airlinefleet"
+gold_answer = "777"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "traceyvanp__airlinefleet"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "traceyvanp/airlinefleet"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "777"
+QUESTION = "Which aircraft type is most commonly used among the selected large aircraft categories (A380, A330, A340, 747, 777, 787) across all airlines in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0048_917_48917297_qa_2/instruction.md b/tasks/0048_917_48917297_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..74ff7963ea9e07d419d07d88a19640dffd6fec4e
--- /dev/null
+++ b/tasks/0048_917_48917297_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- zoo.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many distinct animal classes are present in the dataset based on the 'class_type' column?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0048_917_48917297_qa_2/task.toml b/tasks/0048_917_48917297_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..81027a85a150288619a203f736c470df6c304597
--- /dev/null
+++ b/tasks/0048_917_48917297_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0048_917_48917297_qa_2"
+description = "How many distinct animal classes are present in the dataset based on the 'class_type' column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0048/917/48917297.ipynb_qa_2"
+kaggle_dataset_name = "uciml/zoo-animal-classification"
+gold_answer = "7"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__zoo-animal-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/zoo-animal-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "7"
+QUESTION = "How many distinct animal classes are present in the dataset based on the 'class_type' column?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0048_996_48996091_qa_4/instruction.md b/tasks/0048_996_48996091_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..76dbb2289953415ff56ed82961f4e6c2c61fe2fb
--- /dev/null
+++ b/tasks/0048_996_48996091_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the total number of samples in the test set used for evaluating the model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0048_996_48996091_qa_4/task.toml b/tasks/0048_996_48996091_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ab1e3fafe83da72f3bc5a57ef8ce8986e3e79150
--- /dev/null
+++ b/tasks/0048_996_48996091_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0048_996_48996091_qa_4"
+description = "What was the total number of samples in the test set used for evaluating the model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0048/996/48996091.ipynb_qa_4"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "1625"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1625"
+QUESTION = "What was the total number of samples in the test set used for evaluating the model?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0049_165_49165096_qa_1/instruction.md b/tasks/0049_165_49165096_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f9ad0e44cc335633333315380b94f048b792e94b
--- /dev/null
+++ b/tasks/0049_165_49165096_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- HN_posts_year_to_Sep_26_2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which hour of the day has the highest average number of comments for posts tagged as 'ask'?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0049_165_49165096_qa_1/task.toml b/tasks/0049_165_49165096_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..65b4712a8e405e2352c66af8689e6641bf2dc0ac
--- /dev/null
+++ b/tasks/0049_165_49165096_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0049_165_49165096_qa_1"
+description = "Which hour of the day has the highest average number of comments for posts tagged as 'ask'?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0049/165/49165096.ipynb_qa_1"
+kaggle_dataset_name = "hacker-news/hacker-news-posts"
+gold_answer = "15"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "hacker-news__hacker-news-posts"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "hacker-news/hacker-news-posts"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "15"
+QUESTION = "Which hour of the day has the highest average number of comments for posts tagged as 'ask'?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0049_714_49714638_qa_4/instruction.md b/tasks/0049_714_49714638_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..71a647fdc2c5a206cfebc2b8ee7d04ca8b671ee3
--- /dev/null
+++ b/tasks/0049_714_49714638_qa_4/instruction.md
@@ -0,0 +1,19 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- pokemon.csv
+- combats.csv
+- tests.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which Pokémon have the highest Defense points, and what is their specific Defense value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the exact Pokémon names, followed by a hyphen and the Defense value (e.g., Name1, Name2, Name3 - 230).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0049_714_49714638_qa_4/task.toml b/tasks/0049_714_49714638_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..78f9ba44441f72fd14d4f21f7018b60b3a7defdf
--- /dev/null
+++ b/tasks/0049_714_49714638_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0049_714_49714638_qa_4"
+description = "Which Pokémon have the highest Defense points, and what is their specific Defense value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0049/714/49714638.ipynb_qa_4"
+kaggle_dataset_name = "terminus7/pokemon-challenge"
+gold_answer = "Mega Steelix, Shuckle, Mega Aggron - 230"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "terminus7__pokemon-challenge"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Mega Steelix, Shuckle, Mega Aggron - 230"
+QUESTION = "Which Pokémon have the highest Defense points, and what is their specific Defense value?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0049_762_49762314_qa_3/instruction.md b/tasks/0049_762_49762314_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..044de253ddc9d354dfaadd0ff801b81b4a2b1f40
--- /dev/null
+++ b/tasks/0049_762_49762314_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- HR_comma_sep.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference in average monthly hours between employees who left the company and those who stayed?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0049_762_49762314_qa_3/task.toml b/tasks/0049_762_49762314_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7f41d855172c4dabac616cec5322bcb1f1a9fe09
--- /dev/null
+++ b/tasks/0049_762_49762314_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0049_762_49762314_qa_3"
+description = "What is the difference in average monthly hours between employees who left the company and those who stayed?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0049/762/49762314.ipynb_qa_3"
+kaggle_dataset_name = "giripujar/hr-analytics"
+gold_answer = "8.359"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "giripujar__hr-analytics"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "giripujar/hr-analytics"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "8.359"
+QUESTION = "What is the difference in average monthly hours between employees who left the company and those who stayed?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0050_334_50334572_qa_4/instruction.md b/tasks/0050_334_50334572_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a970ae229686446cbe7a9f1786ad41e2e48af4b5
--- /dev/null
+++ b/tasks/0050_334_50334572_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- german_credit_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many missing values were present in the 'Checking account' column before imputation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0050_334_50334572_qa_4/task.toml b/tasks/0050_334_50334572_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b4fa4c9eb997963603794dc138f2789f6722c0a4
--- /dev/null
+++ b/tasks/0050_334_50334572_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0050_334_50334572_qa_4"
+description = "How many missing values were present in the 'Checking account' column before imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0050/334/50334572.ipynb_qa_4"
+kaggle_dataset_name = "kabure/german-credit-data-with-risk"
+gold_answer = "394"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kabure__german-credit-data-with-risk"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kabure/german-credit-data-with-risk"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "394"
+QUESTION = "How many missing values were present in the 'Checking account' column before imputation?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0050_587_50587128_qa_4/instruction.md b/tasks/0050_587_50587128_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..debeec27c72930c4551f75deb02453c6f1956b89
--- /dev/null
+++ b/tasks/0050_587_50587128_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- cereal.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many manufacturers produce hot cereals?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0050_587_50587128_qa_4/task.toml b/tasks/0050_587_50587128_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..16d964ae1bb5197ebf0024cc660bccb8b1de3ef0
--- /dev/null
+++ b/tasks/0050_587_50587128_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0050_587_50587128_qa_4"
+description = "How many manufacturers produce hot cereals?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0050/587/50587128.ipynb_qa_4"
+kaggle_dataset_name = "crawford/80-cereals"
+gold_answer = "3"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "crawford__80-cereals"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crawford/80-cereals"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3"
+QUESTION = "How many manufacturers produce hot cereals?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0050_775_50775571_qa_1/instruction.md b/tasks/0050_775_50775571_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bdd67f11bb54a3af5620a1de6a8c2043b6752487
--- /dev/null
+++ b/tasks/0050_775_50775571_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+- test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the feature with the highest absolute correlation with the target variable 'SalePrice' in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0050_775_50775571_qa_1/task.toml b/tasks/0050_775_50775571_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3334b1dadb75a23181c35a98716e7eb75adeeb4c
--- /dev/null
+++ b/tasks/0050_775_50775571_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0050_775_50775571_qa_1"
+description = "What is the feature with the highest absolute correlation with the target variable 'SalePrice' in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0050/775/50775571.ipynb_qa_1"
+kaggle_dataset_name = "lespin/house-prices-dataset"
+gold_answer = "OverallQual"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "lespin__house-prices-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "lespin/house-prices-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "OverallQual"
+QUESTION = "What is the feature with the highest absolute correlation with the target variable 'SalePrice' in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0051_063_51063179_qa_2/instruction.md b/tasks/0051_063_51063179_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a9daa987c602a16707f743b317b9e87ecd6b9037
--- /dev/null
+++ b/tasks/0051_063_51063179_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which species is characterized by having Petal Lengths consistently below 2 cm based on the analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0051_063_51063179_qa_2/task.toml b/tasks/0051_063_51063179_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..72cc5e74dc6d3d0f34b961e35dd63085d40630f3
--- /dev/null
+++ b/tasks/0051_063_51063179_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0051_063_51063179_qa_2"
+description = "Which species is characterized by having Petal Lengths consistently below 2 cm based on the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0051/063/51063179.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "Iris-setosa"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Iris-setosa"
+QUESTION = "Which species is characterized by having Petal Lengths consistently below 2 cm based on the analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0051_530_51530318_qa_2/instruction.md b/tasks/0051_530_51530318_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9724d09fef8ecf384cba904fc01138e9a97355d3
--- /dev/null
+++ b/tasks/0051_530_51530318_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many unique content entries exist in the "ham" category compared to the "spam" category?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as comma-separated <category>=<count> pairs, category first, with plain numbers.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0051_530_51530318_qa_2/task.toml b/tasks/0051_530_51530318_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6199ec16c51777528cf0ca4034b6d1af03a4ac49
--- /dev/null
+++ b/tasks/0051_530_51530318_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0051_530_51530318_qa_2"
+description = "How many unique content entries exist in the \"ham\" category compared to the \"spam\" category?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0051/530/51530318.ipynb_qa_2"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "ham=4516, spam=653"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "ham=4516, spam=653"
+QUESTION = "How many unique content entries exist in the \"ham\" category compared to the \"spam\" category?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0051_530_51530318_qa_3/instruction.md b/tasks/0051_530_51530318_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..30f1e533313f0f488b8cd69939aa47dd5273ac16
--- /dev/null
+++ b/tasks/0051_530_51530318_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the accuracy score of the Multinomial Naive Bayes model on the test dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0051_530_51530318_qa_3/task.toml b/tasks/0051_530_51530318_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6b038bbbac447ca5e80bbc17324887496a9a68c4
--- /dev/null
+++ b/tasks/0051_530_51530318_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0051_530_51530318_qa_3"
+description = "What is the accuracy score of the Multinomial Naive Bayes model on the test dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0051/530/51530318.ipynb_qa_3"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "0.9828"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.9828"
+QUESTION = "What is the accuracy score of the Multinomial Naive Bayes model on the test dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0051_967_51967182_qa_2/instruction.md b/tasks/0051_967_51967182_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..41b80d149da632e30949fde668d5d8e6dfdcf04a
--- /dev/null
+++ b/tasks/0051_967_51967182_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which region has the highest number of policyholders in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0051_967_51967182_qa_2/task.toml b/tasks/0051_967_51967182_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..03ed896a102d47ced93cdfa148a61efc59345a0b
--- /dev/null
+++ b/tasks/0051_967_51967182_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0051_967_51967182_qa_2"
+description = "Which region has the highest number of policyholders in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0051/967/51967182.ipynb_qa_2"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "southeast"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "southeast"
+QUESTION = "Which region has the highest number of policyholders in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0051_967_51967182_qa_4/instruction.md b/tasks/0051_967_51967182_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f2d2bab8ff916e700e0034739617f05fb9f77bb5
--- /dev/null
+++ b/tasks/0051_967_51967182_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average number of dependents covered by health insurance per policyholder?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0051_967_51967182_qa_4/task.toml b/tasks/0051_967_51967182_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..943aac0762fdfa723c581d169971dcd820598f34
--- /dev/null
+++ b/tasks/0051_967_51967182_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0051_967_51967182_qa_4"
+description = "What is the average number of dependents covered by health insurance per policyholder?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0051/967/51967182.ipynb_qa_4"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "1.09"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.09"
+QUESTION = "What is the average number of dependents covered by health insurance per policyholder?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0052_521_52521020_qa_2/instruction.md b/tasks/0052_521_52521020_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..910b39259541f7bc3d6eb125a3ac69bdd641f9b4
--- /dev/null
+++ b/tasks/0052_521_52521020_qa_2/instruction.md
@@ -0,0 +1,18 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- kiva_loans.csv
+- kiva_mpi_region_locations.csv
+- loan_theme_ids.csv
+- loan_themes_by_region.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common repayment interval type for Kiva loans in Rwanda?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0052_521_52521020_qa_2/task.toml b/tasks/0052_521_52521020_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5b69424c469cdd947b29bf82ba496e13f52841cf
--- /dev/null
+++ b/tasks/0052_521_52521020_qa_2/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0052_521_52521020_qa_2"
+description = "What is the most common repayment interval type for Kiva loans in Rwanda?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0052/521/52521020.ipynb_qa_2"
+kaggle_dataset_name = "kiva/data-science-for-good-kiva-crowdfunding"
+gold_answer = "Irregular"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kiva__data-science-for-good-kiva-crowdfunding"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kiva/data-science-for-good-kiva-crowdfunding"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Irregular"
+QUESTION = "What is the most common repayment interval type for Kiva loans in Rwanda?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0052_586_52586560_qa_3/instruction.md b/tasks/0052_586_52586560_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..01cc26b7c85baf90412b36b7339904e0622407e6
--- /dev/null
+++ b/tasks/0052_586_52586560_qa_3/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Train.csv
+- Test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common outlet size category in the training data?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0052_586_52586560_qa_3/task.toml b/tasks/0052_586_52586560_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..adc004da1418dc3b589af33c46c949c70f02cbae
--- /dev/null
+++ b/tasks/0052_586_52586560_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0052_586_52586560_qa_3"
+description = "What is the most common outlet size category in the training data?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0052/586/52586560.ipynb_qa_3"
+kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data"
+gold_answer = "Medium"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Medium"
+QUESTION = "What is the most common outlet size category in the training data?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0052_586_52586560_qa_4/instruction.md b/tasks/0052_586_52586560_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cbd9b10bc31eeef32f62aa1db24ed70f2ca43c1d
--- /dev/null
+++ b/tasks/0052_586_52586560_qa_4/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Train.csv
+- Test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the skewness value of the Item_Outlet_Sales distribution in the training dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0052_586_52586560_qa_4/task.toml b/tasks/0052_586_52586560_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a2c469455cbbc5319eecdf68816894ee1e2a87e2
--- /dev/null
+++ b/tasks/0052_586_52586560_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0052_586_52586560_qa_4"
+description = "What is the skewness value of the Item_Outlet_Sales distribution in the training dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0052/586/52586560.ipynb_qa_4"
+kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data"
+gold_answer = "1.1775306028542798"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.1775306028542798"
+QUESTION = "What is the skewness value of the Item_Outlet_Sales distribution in the training dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0053_354_53354710_qa_5/instruction.md b/tasks/0053_354_53354710_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..baaafdb2578bd74168ebe9694a6b2d1328d58499
--- /dev/null
+++ b/tasks/0053_354_53354710_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of the women in the dataset have BMI values within the normal weight range (18.5–24.9)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0053_354_53354710_qa_5/task.toml b/tasks/0053_354_53354710_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8cb51f6993a02cff7849925fe1653c92dbebb342
--- /dev/null
+++ b/tasks/0053_354_53354710_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0053_354_53354710_qa_5"
+description = "What percentage of the women in the dataset have BMI values within the normal weight range (18.5–24.9)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0053/354/53354710.ipynb_qa_5"
+kaggle_dataset_name = "tmcketterick/heights-and-weights"
+gold_answer = "100"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "tmcketterick__heights-and-weights"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tmcketterick/heights-and-weights"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "100"
+QUESTION = "What percentage of the women in the dataset have BMI values within the normal weight range (18.5–24.9)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0053_455_53455714_qa_3/instruction.md b/tasks/0053_455_53455714_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8414fc6b272e7013d8f87674b5f31b97d003da32
--- /dev/null
+++ b/tasks/0053_455_53455714_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which four features are used as input variables for the K-Nearest Neighbors classification model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the exact column names.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0053_455_53455714_qa_3/task.toml b/tasks/0053_455_53455714_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3ad7c2fd73a32a4533ca577e44f14c3c6f959286
--- /dev/null
+++ b/tasks/0053_455_53455714_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0053_455_53455714_qa_3"
+description = "Which four features are used as input variables for the K-Nearest Neighbors classification model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0053/455/53455714.ipynb_qa_3"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "SepalLengthCm, SepalWidthCm, PetalLengthCm, PetalWidthCm"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "SepalLengthCm, SepalWidthCm, PetalLengthCm, PetalWidthCm"
+QUESTION = "Which four features are used as input variables for the K-Nearest Neighbors classification model?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0053_768_53768671_qa_2/instruction.md b/tasks/0053_768_53768671_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..895f38c4e90900508e7122a70128eb8bd33822ea
--- /dev/null
+++ b/tasks/0053_768_53768671_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of patients in the dataset are diagnosed with diabetes based on the outcome variable?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0053_768_53768671_qa_2/task.toml b/tasks/0053_768_53768671_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..effed22258cccabec53cd5e6ca4af199a5b9228c
--- /dev/null
+++ b/tasks/0053_768_53768671_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0053_768_53768671_qa_2"
+description = "What percentage of patients in the dataset are diagnosed with diabetes based on the outcome variable?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0053/768/53768671.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "34.9"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "34.9"
+QUESTION = "What percentage of patients in the dataset are diagnosed with diabetes based on the outcome variable?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0054_296_54296946_qa_1/instruction.md b/tasks/0054_296_54296946_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ef73170faba30d019bf4dba5449e9a95b4471589
--- /dev/null
+++ b/tasks/0054_296_54296946_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+- test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the dataset shows the highest correlation with the price_range variable based on the correlation matrix analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0054_296_54296946_qa_1/task.toml b/tasks/0054_296_54296946_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..34506da8cc4ed04dacdd155c24be43dcb74fbe40
--- /dev/null
+++ b/tasks/0054_296_54296946_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0054_296_54296946_qa_1"
+description = "Which feature in the dataset shows the highest correlation with the price_range variable based on the correlation matrix analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0054/296/54296946.ipynb_qa_1"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "ram"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "ram"
+QUESTION = "Which feature in the dataset shows the highest correlation with the price_range variable based on the correlation matrix analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0054_514_54514604_qa_1/instruction.md b/tasks/0054_514_54514604_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0e9a8793b69a24c5e5f856e5c78bda09d4b90050
--- /dev/null
+++ b/tasks/0054_514_54514604_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest recorded insurance charge in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0054_514_54514604_qa_1/task.toml b/tasks/0054_514_54514604_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e2177255ab24a8028c4b6d7ff9d48f737ae6edc8
--- /dev/null
+++ b/tasks/0054_514_54514604_qa_1/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0054_514_54514604_qa_1"
+description = "What is the highest recorded insurance charge in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0054/514/54514604.ipynb_qa_1"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "63770.43"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "63770.43"
+QUESTION = "What is the highest recorded insurance charge in the dataset?"
+REWARD_MODE = "numeric"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0055_027_55027246_qa_2/instruction.md b/tasks/0055_027_55027246_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6b2df864ef2bcb06f59e118fb402aab58f6e9a34
--- /dev/null
+++ b/tasks/0055_027_55027246_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Salary_Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Does the dataset contain any duplicate records based on the combination of YearsExperience and Salary?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0055_027_55027246_qa_2/task.toml b/tasks/0055_027_55027246_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..084e3eb273849371a74d9e867cb80f19557ba63c
--- /dev/null
+++ b/tasks/0055_027_55027246_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0055_027_55027246_qa_2"
+description = "Does the dataset contain any duplicate records based on the combination of YearsExperience and Salary?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0055/027/55027246.ipynb_qa_2"
+kaggle_dataset_name = "rohankayan/years-of-experience-and-salary-dataset"
+gold_answer = "no"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rohankayan__years-of-experience-and-salary-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rohankayan/years-of-experience-and-salary-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "no"
+QUESTION = "Does the dataset contain any duplicate records based on the combination of YearsExperience and Salary?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0055_027_55027246_qa_4/instruction.md b/tasks/0055_027_55027246_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7a3377754c0320c9bbdb5483d6dc7a9b607373e3
--- /dev/null
+++ b/tasks/0055_027_55027246_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Salary_Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many unique salary entries are present in the dataset considering no duplicates exist?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0055_027_55027246_qa_4/task.toml b/tasks/0055_027_55027246_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..98f1f97600c294b43b662c20b43c5ce434e146ab
--- /dev/null
+++ b/tasks/0055_027_55027246_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0055_027_55027246_qa_4"
+description = "How many unique salary entries are present in the dataset considering no duplicates exist?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0055/027/55027246.ipynb_qa_4"
+kaggle_dataset_name = "rohankayan/years-of-experience-and-salary-dataset"
+gold_answer = "30"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rohankayan__years-of-experience-and-salary-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rohankayan/years-of-experience-and-salary-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "30"
+QUESTION = "How many unique salary entries are present in the dataset considering no duplicates exist?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0055_310_55310713_qa_3/instruction.md b/tasks/0055_310_55310713_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c8f75e27bee6dc8c7bc96007800f86a27f5162ba
--- /dev/null
+++ b/tasks/0055_310_55310713_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which platform achieved the highest total global sales in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0055_310_55310713_qa_3/task.toml b/tasks/0055_310_55310713_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..286566747570d7c16ce7c5b16c3d4864f09cb525
--- /dev/null
+++ b/tasks/0055_310_55310713_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0055_310_55310713_qa_3"
+description = "Which platform achieved the highest total global sales in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0055/310/55310713.ipynb_qa_3"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "PS2"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "PS2"
+QUESTION = "Which platform achieved the highest total global sales in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0055_310_55310713_qa_4/instruction.md b/tasks/0055_310_55310713_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b8a0d5a4fc8333b421f3b45c37bc264cc6a178f4
--- /dev/null
+++ b/tasks/0055_310_55310713_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which publisher had the most game releases in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0055_310_55310713_qa_4/task.toml b/tasks/0055_310_55310713_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e85643dac94fd15dcf95c41498553f4f63aea7c5
--- /dev/null
+++ b/tasks/0055_310_55310713_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0055_310_55310713_qa_4"
+description = "Which publisher had the most game releases in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0055/310/55310713.ipynb_qa_4"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Electronic Arts"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Electronic Arts"
+QUESTION = "Which publisher had the most game releases in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0055_717_55717074_qa_4/instruction.md b/tasks/0055_717_55717074_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ba68e3a0e87f007c71666ffdab94c81abd69fed5
--- /dev/null
+++ b/tasks/0055_717_55717074_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many more individuals are classified as non-diabetic compared to diabetic in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0055_717_55717074_qa_4/task.toml b/tasks/0055_717_55717074_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7648826539b907c37eb11e771c6ed549281bb980
--- /dev/null
+++ b/tasks/0055_717_55717074_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0055_717_55717074_qa_4"
+description = "How many more individuals are classified as non-diabetic compared to diabetic in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0055/717/55717074.ipynb_qa_4"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "232"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "232"
+QUESTION = "How many more individuals are classified as non-diabetic compared to diabetic in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0055_834_55834525_qa_1/instruction.md b/tasks/0055_834_55834525_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2d7e9232086ee1275aa021abb068a6ce0fd64200
--- /dev/null
+++ b/tasks/0055_834_55834525_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Loan payments data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of loans in the dataset were paid on time (PAIDOFF status)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0055_834_55834525_qa_1/task.toml b/tasks/0055_834_55834525_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a3819d777c55d3d56c9bbc259441259caca5c12c
--- /dev/null
+++ b/tasks/0055_834_55834525_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0055_834_55834525_qa_1"
+description = "What percentage of loans in the dataset were paid on time (PAIDOFF status)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0055/834/55834525.ipynb_qa_1"
+kaggle_dataset_name = "zhijinzhai/loandata"
+gold_answer = "60"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "zhijinzhai__loandata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zhijinzhai/loandata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "60"
+QUESTION = "What percentage of loans in the dataset were paid on time (PAIDOFF status)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0056_224_56224214_qa_4/instruction.md b/tasks/0056_224_56224214_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5ab5002cd694f229b1165d3385e864dd2ae8d44
--- /dev/null
+++ b/tasks/0056_224_56224214_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference between the highest and lowest individual classifier test accuracy when trained on separate data subsets?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0056_224_56224214_qa_4/task.toml b/tasks/0056_224_56224214_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..eda9360befe8a2c0718e4b28ba41e54581f44cda
--- /dev/null
+++ b/tasks/0056_224_56224214_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0056_224_56224214_qa_4"
+description = "What is the difference between the highest and lowest individual classifier test accuracy when trained on separate data subsets?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0056/224/56224214.ipynb_qa_4"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "0.06"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.06"
+QUESTION = "What is the difference between the highest and lowest individual classifier test accuracy when trained on separate data subsets?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0056_266_56266405_qa_3/instruction.md b/tasks/0056_266_56266405_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e38e194f873306ca0fb10df64f884387c72e86c1
--- /dev/null
+++ b/tasks/0056_266_56266405_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- adult.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which occupation has the highest ratio of individuals earning more than 50K according to the dataset analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0056_266_56266405_qa_3/task.toml b/tasks/0056_266_56266405_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5f42082340ff32402eef6108f8a89c44fa4558e3
--- /dev/null
+++ b/tasks/0056_266_56266405_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0056_266_56266405_qa_3"
+description = "Which occupation has the highest ratio of individuals earning more than 50K according to the dataset analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0056/266/56266405.ipynb_qa_3"
+kaggle_dataset_name = "uciml/adult-census-income"
+gold_answer = "Exec-Managerial"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__adult-census-income"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/adult-census-income"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Exec-Managerial"
+QUESTION = "Which occupation has the highest ratio of individuals earning more than 50K according to the dataset analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0056_266_56266405_qa_4/instruction.md b/tasks/0056_266_56266405_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7dfda751b1c86680d42001d3408798e47f2375e1
--- /dev/null
+++ b/tasks/0056_266_56266405_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average capital gain for all individuals in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0056_266_56266405_qa_4/task.toml b/tasks/0056_266_56266405_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..45b0896657e98eb5b9bfa2f7783ad5b3b0d5a0c2
--- /dev/null
+++ b/tasks/0056_266_56266405_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0056_266_56266405_qa_4"
+description = "What is the average capital gain for all individuals in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0056/266/56266405.ipynb_qa_4"
+kaggle_dataset_name = "uciml/adult-census-income"
+gold_answer = "1085.15"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__adult-census-income"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/adult-census-income"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1085.15"
+QUESTION = "What is the average capital gain for all individuals in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0056_269_56269828_qa_2/instruction.md b/tasks/0056_269_56269828_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..175ba9d8c9b6a7c45b0be7c3c8f0dd232e951dd3
--- /dev/null
+++ b/tasks/0056_269_56269828_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Life Expectancy Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the skewness value of the 'Alcohol' distribution after handling missing values in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0056_269_56269828_qa_2/task.toml b/tasks/0056_269_56269828_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c7f9998e6bf4b7c878d59eff16aa0d90b7be3a06
--- /dev/null
+++ b/tasks/0056_269_56269828_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0056_269_56269828_qa_2"
+description = "What is the skewness value of the 'Alcohol' distribution after handling missing values in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0056/269/56269828.ipynb_qa_2"
+kaggle_dataset_name = "kumarajarshi/life-expectancy-who"
+gold_answer = "0.5972237000216292"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kumarajarshi__life-expectancy-who"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.5972237000216292"
+QUESTION = "What is the skewness value of the 'Alcohol' distribution after handling missing values in the dataset?"
+REWARD_MODE = "flexible"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0056_269_56269828_qa_3/instruction.md b/tasks/0056_269_56269828_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..566a891a55095bdc04f4ea3182d7d267049de2a3
--- /dev/null
+++ b/tasks/0056_269_56269828_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Life Expectancy Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature shows the strongest positive correlation with 'Schooling' after imputing missing values in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0056_269_56269828_qa_3/task.toml b/tasks/0056_269_56269828_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..60679f8fff1509272eed961dc6503635e8d0745e
--- /dev/null
+++ b/tasks/0056_269_56269828_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0056_269_56269828_qa_3"
+description = "Which feature shows the strongest positive correlation with 'Schooling' after imputing missing values in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0056/269/56269828.ipynb_qa_3"
+kaggle_dataset_name = "kumarajarshi/life-expectancy-who"
+gold_answer = "Income composition of resources"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kumarajarshi__life-expectancy-who"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Income composition of resources"
+QUESTION = "Which feature shows the strongest positive correlation with 'Schooling' after imputing missing values in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0056_414_56414713_qa_4/instruction.md b/tasks/0056_414_56414713_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..edf8d137dcfb88f4b0479cacbe17e91d64bb71f1
--- /dev/null
+++ b/tasks/0056_414_56414713_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the accuracy score achieved by the Random Forest model after binning the wine quality into three categories (bad, medium, good)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0056_414_56414713_qa_4/task.toml b/tasks/0056_414_56414713_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d83f22bc87fcb5b965f4d13e89749175f5c7e31e
--- /dev/null
+++ b/tasks/0056_414_56414713_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0056_414_56414713_qa_4"
+description = "What is the accuracy score achieved by the Random Forest model after binning the wine quality into three categories (bad, medium, good)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0056/414/56414713.ipynb_qa_4"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "0.8651"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.8651"
+QUESTION = "What is the accuracy score achieved by the Random Forest model after binning the wine quality into three categories (bad, medium, good)?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0057_640_57640669_qa_4/instruction.md b/tasks/0057_640_57640669_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..247c01be8b86338785738cbeb3c9c22ca20fa2c8
--- /dev/null
+++ b/tasks/0057_640_57640669_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- SPAM text message 20170820 - Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many unique words were present in the initial tokenization before limiting the vocabulary size to 3000?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0057_640_57640669_qa_4/task.toml b/tasks/0057_640_57640669_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a7605b1c86b8a80e9d2e5590aad9ee088f91bceb
--- /dev/null
+++ b/tasks/0057_640_57640669_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0057_640_57640669_qa_4"
+description = "How many unique words were present in the initial tokenization before limiting the vocabulary size to 3000?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0057/640/57640669.ipynb_qa_4"
+kaggle_dataset_name = "team-ai/spam-text-message-classification"
+gold_answer = "9004"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "team-ai__spam-text-message-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "team-ai/spam-text-message-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "9004"
+QUESTION = "How many unique words were present in the initial tokenization before limiting the vocabulary size to 3000?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0057_686_57686190_qa_1/instruction.md b/tasks/0057_686_57686190_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f43c702503df28f4b04c8c5b402782c12627343b
--- /dev/null
+++ b/tasks/0057_686_57686190_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- bigml_59c28831336c6604c800002a.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the accuracy of the best performing model on the test dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0057_686_57686190_qa_1/task.toml b/tasks/0057_686_57686190_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..781c03df13db896b88ca658770b04adcef4ec0df
--- /dev/null
+++ b/tasks/0057_686_57686190_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0057_686_57686190_qa_1"
+description = "What is the accuracy of the best performing model on the test dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0057/686/57686190.ipynb_qa_1"
+kaggle_dataset_name = "becksddf/churn-in-telecoms-dataset"
+gold_answer = "0.9580838323353293"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "becksddf__churn-in-telecoms-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "becksddf/churn-in-telecoms-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.9580838323353293"
+QUESTION = "What is the accuracy of the best performing model on the test dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0057_778_57778333_qa_1/instruction.md b/tasks/0057_778_57778333_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0bde85feb47b421c0270d244e1a1c5d1bfb0239
--- /dev/null
+++ b/tasks/0057_778_57778333_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diamonds.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many rows in the dataset contain zero values in any of the x, y, or z dimensions (diamond dimensions)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0057_778_57778333_qa_1/task.toml b/tasks/0057_778_57778333_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..36945fa2bffc7299c8d921ebe162f90edfeedb4b
--- /dev/null
+++ b/tasks/0057_778_57778333_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0057_778_57778333_qa_1"
+description = "How many rows in the dataset contain zero values in any of the x, y, or z dimensions (diamond dimensions)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0057/778/57778333.ipynb_qa_1"
+kaggle_dataset_name = "shivam2503/diamonds"
+gold_answer = "20"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "shivam2503__diamonds"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "shivam2503/diamonds"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "20"
+QUESTION = "How many rows in the dataset contain zero values in any of the x, y, or z dimensions (diamond dimensions)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0057_851_57851395_qa_2/instruction.md b/tasks/0057_851_57851395_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..33615bd0722a5a853d779e1051cb54eddd5d081e
--- /dev/null
+++ b/tasks/0057_851_57851395_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- ENB2012_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the minimum value of the Roof Area (X4) in the training data?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0057_851_57851395_qa_2/task.toml b/tasks/0057_851_57851395_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2ac23414f689a098c364fd51a263b4a7603a1ed6
--- /dev/null
+++ b/tasks/0057_851_57851395_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0057_851_57851395_qa_2"
+description = "What is the minimum value of the Roof Area (X4) in the training data?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0057/851/57851395.ipynb_qa_2"
+kaggle_dataset_name = "elikplim/eergy-efficiency-dataset"
+gold_answer = "110.25"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "elikplim__eergy-efficiency-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "elikplim/eergy-efficiency-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "110.25"
+QUESTION = "What is the minimum value of the Roof Area (X4) in the training data?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0058_275_58275852_qa_3/instruction.md b/tasks/0058_275_58275852_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1bc5c2ef4965109e9e9eaf9b7f13675fd15367eb
--- /dev/null
+++ b/tasks/0058_275_58275852_qa_3/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Train.csv
+- Test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After log transformation, what is the skewness value of the 'Item_Outlet_Sales' feature?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0058_275_58275852_qa_3/task.toml b/tasks/0058_275_58275852_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4ba3d0219d39e10fbff7a258f45554deff54ca1d
--- /dev/null
+++ b/tasks/0058_275_58275852_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0058_275_58275852_qa_3"
+description = "After log transformation, what is the skewness value of the 'Item_Outlet_Sales' feature?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0058/275/58275852.ipynb_qa_3"
+kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data"
+gold_answer = "-0.887753"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-0.887753"
+QUESTION = "After log transformation, what is the skewness value of the 'Item_Outlet_Sales' feature?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0058_565_58565902_qa_1/instruction.md b/tasks/0058_565_58565902_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..94f79af1ebaf2e202b556173a20d8f026e1d53fb
--- /dev/null
+++ b/tasks/0058_565_58565902_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature shows the highest correlation with the target variable in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0058_565_58565902_qa_1/task.toml b/tasks/0058_565_58565902_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cca290ab9062a2d2e7f09bd480bd26f06d1ad3f9
--- /dev/null
+++ b/tasks/0058_565_58565902_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0058_565_58565902_qa_1"
+description = "Which feature shows the highest correlation with the target variable in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0058/565/58565902.ipynb_qa_1"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "concave points_worst"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "concave points_worst"
+QUESTION = "Which feature shows the highest correlation with the target variable in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0058_806_58806875_qa_4/instruction.md b/tasks/0058_806_58806875_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2a94d3b65684a3867bd6aa9f8b64ebbb24ce8408
--- /dev/null
+++ b/tasks/0058_806_58806875_qa_4/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which column in the original dataset has the highest number of missing values, and how many are missing?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list with the exact column name first, then the number of missing values (plain number).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0058_806_58806875_qa_4/task.toml b/tasks/0058_806_58806875_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1b273bb0f3d20239fd901c1a6ed694927971c103
--- /dev/null
+++ b/tasks/0058_806_58806875_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0058_806_58806875_qa_4"
+description = "Which column in the original dataset has the highest number of missing values, and how many are missing?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0058/806/58806875.ipynb_qa_4"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "Unnamed: 32, 569"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Unnamed: 32, 569"
+QUESTION = "Which column in the original dataset has the highest number of missing values, and how many are missing?"
+REWARD_MODE = "list_csv"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0059_575_59575558_qa_3/instruction.md b/tasks/0059_575_59575558_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4d02e8c35612f495b6a46b736ab71ee7afdd2d82
--- /dev/null
+++ b/tasks/0059_575_59575558_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many distinct categories are present in the Neighborhood variable before applying rare label encoding?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0059_575_59575558_qa_3/task.toml b/tasks/0059_575_59575558_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c1133d036bb6a80404820f99d208f8dae351770d
--- /dev/null
+++ b/tasks/0059_575_59575558_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0059_575_59575558_qa_3"
+description = "How many distinct categories are present in the Neighborhood variable before applying rare label encoding?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0059/575/59575558.ipynb_qa_3"
+kaggle_dataset_name = "lespin/house-prices-dataset"
+gold_answer = "25"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "lespin__house-prices-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "lespin/house-prices-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "25"
+QUESTION = "How many distinct categories are present in the Neighborhood variable before applying rare label encoding?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0060_239_60239619_qa_4/instruction.md b/tasks/0060_239_60239619_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..73d5aefbff3573baffb5af08d5643da0e222489a
--- /dev/null
+++ b/tasks/0060_239_60239619_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of observations for each species in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0060_239_60239619_qa_4/task.toml b/tasks/0060_239_60239619_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2493b9f051444ba5d08fc2ddd72f5440548cfe88
--- /dev/null
+++ b/tasks/0060_239_60239619_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0060_239_60239619_qa_4"
+description = "What is the total number of observations for each species in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0060/239/60239619.ipynb_qa_4"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "50"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "50"
+QUESTION = "What is the total number of observations for each species in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0060_435_60435924_qa_3/instruction.md b/tasks/0060_435_60435924_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e6db1b53e006e74836cb6a281d72daca5b81a16c
--- /dev/null
+++ b/tasks/0060_435_60435924_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- concrete_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median age (in days) of the concrete samples in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0060_435_60435924_qa_3/task.toml b/tasks/0060_435_60435924_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b18bbbea1338127b9edd255aaac2a9f625903cd2
--- /dev/null
+++ b/tasks/0060_435_60435924_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0060_435_60435924_qa_3"
+description = "What is the median age (in days) of the concrete samples in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0060/435/60435924.ipynb_qa_3"
+kaggle_dataset_name = "elikplim/concrete-compressive-strength-data-set"
+gold_answer = "28"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "elikplim__concrete-compressive-strength-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "elikplim/concrete-compressive-strength-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "28"
+QUESTION = "What is the median age (in days) of the concrete samples in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0060_577_60577566_qa_2/instruction.md b/tasks/0060_577_60577566_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e349bb9092c816ccf22713052f29670b3342a07b
--- /dev/null
+++ b/tasks/0060_577_60577566_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which video game has the highest global sales according to the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0060_577_60577566_qa_2/task.toml b/tasks/0060_577_60577566_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8541bce254b0a6960ecd5aa8c941f71362e0ee9a
--- /dev/null
+++ b/tasks/0060_577_60577566_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0060_577_60577566_qa_2"
+description = "Which video game has the highest global sales according to the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0060/577/60577566.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Wii Sports"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Wii Sports"
+QUESTION = "Which video game has the highest global sales according to the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0060_577_60577566_qa_5/instruction.md b/tasks/0060_577_60577566_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2bff0603af1ce7bf85aa44c3293094e111134fd8
--- /dev/null
+++ b/tasks/0060_577_60577566_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average release year of video games in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0060_577_60577566_qa_5/task.toml b/tasks/0060_577_60577566_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0a6dbf066056ad44f1f70a6a5154f644c3fa001d
--- /dev/null
+++ b/tasks/0060_577_60577566_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0060_577_60577566_qa_5"
+description = "What is the average release year of video games in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0060/577/60577566.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "2006.4"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2006.4"
+QUESTION = "What is the average release year of video games in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0060_651_60651529_qa_4/instruction.md b/tasks/0060_651_60651529_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7932fe2886c2b2732ea0170a831f998c854fb9ef
--- /dev/null
+++ b/tasks/0060_651_60651529_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- tweets.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of tweets in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0060_651_60651529_qa_4/task.toml b/tasks/0060_651_60651529_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..43d0a5c5bba673d4d1ec7677ea3ea91ec5d28337
--- /dev/null
+++ b/tasks/0060_651_60651529_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0060_651_60651529_qa_4"
+description = "What is the total number of tweets in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0060/651/60651529.ipynb_qa_4"
+kaggle_dataset_name = "benhamner/clinton-trump-tweets"
+gold_answer = "6,444 tweets"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "benhamner__clinton-trump-tweets"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "benhamner/clinton-trump-tweets"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6,444 tweets"
+QUESTION = "What is the total number of tweets in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0061_146_61146157_qa_1/instruction.md b/tasks/0061_146_61146157_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..09a53495ab35253525b0c677caccb0a4e1850e79
--- /dev/null
+++ b/tasks/0061_146_61146157_qa_1/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Wine.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which wine class has the highest frequency in the dataset, and how many instances does it contain?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <class>, <count> (comma-separated, label first, keep the number as an integer).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0061_146_61146157_qa_1/task.toml b/tasks/0061_146_61146157_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d99827002844f7bc9ce0134be93ea68ab332d681
--- /dev/null
+++ b/tasks/0061_146_61146157_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0061_146_61146157_qa_1"
+description = "Which wine class has the highest frequency in the dataset, and how many instances does it contain?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0061/146/61146157.ipynb_qa_1"
+kaggle_dataset_name = "brynja/wineuci"
+gold_answer = "Class 2, 71"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brynja__wineuci"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brynja/wineuci"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Class 2, 71"
+QUESTION = "Which wine class has the highest frequency in the dataset, and how many instances does it contain?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0061_292_61292134_qa_3/instruction.md b/tasks/0061_292_61292134_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac7a0a39657caa9f988d6161636ca3b946559f3d
--- /dev/null
+++ b/tasks/0061_292_61292134_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After applying SMOTE with a target of 1000 samples per class, what is the new count for each quality rating?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0061_292_61292134_qa_3/task.toml b/tasks/0061_292_61292134_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7d73ac91bf20a19ae44222fe39556fc61739cde3
--- /dev/null
+++ b/tasks/0061_292_61292134_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0061_292_61292134_qa_3"
+description = "After applying SMOTE with a target of 1000 samples per class, what is the new count for each quality rating?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0061/292/61292134.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "1000"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1000"
+QUESTION = "After applying SMOTE with a target of 1000 samples per class, what is the new count for each quality rating?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0061_837_61837525_qa_5/instruction.md b/tasks/0061_837_61837525_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..11f9aab0db39c001c5a000e69fbaee26fd4fee9c
--- /dev/null
+++ b/tasks/0061_837_61837525_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the weighted average F1-score of the model on the test set?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0061_837_61837525_qa_5/task.toml b/tasks/0061_837_61837525_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cc3940da27533bb88e01b5e4385f0c2a083e9370
--- /dev/null
+++ b/tasks/0061_837_61837525_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0061_837_61837525_qa_5"
+description = "What is the weighted average F1-score of the model on the test set?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0061/837/61837525.ipynb_qa_5"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "0.93"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.93"
+QUESTION = "What is the weighted average F1-score of the model on the test set?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0062_214_62214042_qa_5/instruction.md b/tasks/0062_214_62214042_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..11bbaf728cc6bbb364638fca73f940a78303d32c
--- /dev/null
+++ b/tasks/0062_214_62214042_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- My Uber Drives - 2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the longest single trip in miles, and what was its purpose?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <distance> miles, <purpose> (comma-separated, distance first with one decimal, purpose second).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0062_214_62214042_qa_5/task.toml b/tasks/0062_214_62214042_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fc1b26eb234868c2178e3b3ad0722de8f11614e1
--- /dev/null
+++ b/tasks/0062_214_62214042_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0062_214_62214042_qa_5"
+description = "What is the longest single trip in miles, and what was its purpose?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0062/214/62214042.ipynb_qa_5"
+kaggle_dataset_name = "zusmani/uberdrives"
+gold_answer = "310.3 miles, Customer Visit"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "zusmani__uberdrives"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zusmani/uberdrives"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "310.3 miles, Customer Visit"
+QUESTION = "What is the longest single trip in miles, and what was its purpose?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0062_379_62379173_qa_2/instruction.md b/tasks/0062_379_62379173_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1a98f41fe861a027f2fc96cb8960d114f1ab72b3
--- /dev/null
+++ b/tasks/0062_379_62379173_qa_2/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- artists.csv
+- artworks.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of the 'Death Year' data is missing in the artists dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0062_379_62379173_qa_2/task.toml b/tasks/0062_379_62379173_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f6ad68d4d3e357811bc4fbf715277aecbce444be
--- /dev/null
+++ b/tasks/0062_379_62379173_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0062_379_62379173_qa_2"
+description = "What percentage of the 'Death Year' data is missing in the artists dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0062/379/62379173.ipynb_qa_2"
+kaggle_dataset_name = "momanyc/museum-collection"
+gold_answer = "69.66"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "momanyc__museum-collection"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "momanyc/museum-collection"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "69.66"
+QUESTION = "What percentage of the 'Death Year' data is missing in the artists dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0062_379_62379173_qa_3/instruction.md b/tasks/0062_379_62379173_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5ce02be6823e8839f1bfd92aa839dcb817bb79b0
--- /dev/null
+++ b/tasks/0062_379_62379173_qa_3/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- artists.csv
+- artworks.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum age recorded for an artist in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0062_379_62379173_qa_3/task.toml b/tasks/0062_379_62379173_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a5aac87b70c15a1059a290cc62204f05bc152a35
--- /dev/null
+++ b/tasks/0062_379_62379173_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0062_379_62379173_qa_3"
+description = "What is the maximum age recorded for an artist in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0062/379/62379173.ipynb_qa_3"
+kaggle_dataset_name = "momanyc/museum-collection"
+gold_answer = "130"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "momanyc__museum-collection"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "momanyc/museum-collection"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "130"
+QUESTION = "What is the maximum age recorded for an artist in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0062_653_62653158_qa_1/instruction.md b/tasks/0062_653_62653158_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..885db3d86a032e819f9412dacf98b6c0564932a5
--- /dev/null
+++ b/tasks/0062_653_62653158_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Automobile_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which car make has the highest frequency in the dataset based on the univariate analysis of the 'make' column?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0062_653_62653158_qa_1/task.toml b/tasks/0062_653_62653158_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..32243665463e0c3ffc300e11f2d7caeb05d1de11
--- /dev/null
+++ b/tasks/0062_653_62653158_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0062_653_62653158_qa_1"
+description = "Which car make has the highest frequency in the dataset based on the univariate analysis of the 'make' column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0062/653/62653158.ipynb_qa_1"
+kaggle_dataset_name = "toramky/automobile-dataset"
+gold_answer = "toyota"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "toramky__automobile-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "toramky/automobile-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "toyota"
+QUESTION = "Which car make has the highest frequency in the dataset based on the univariate analysis of the 'make' column?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0063_038_63038880_qa_3/instruction.md b/tasks/0063_038_63038880_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca30ea4ac402859f362ad80cd413dd29e217199d
--- /dev/null
+++ b/tasks/0063_038_63038880_qa_3/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+- test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many float64 data type columns are in the training dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0063_038_63038880_qa_3/task.toml b/tasks/0063_038_63038880_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d6a450f42745688640d70c2158d792b2da98fa86
--- /dev/null
+++ b/tasks/0063_038_63038880_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0063_038_63038880_qa_3"
+description = "How many float64 data type columns are in the training dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0063/038/63038880.ipynb_qa_3"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "2"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2"
+QUESTION = "How many float64 data type columns are in the training dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0063_243_63243800_qa_2/instruction.md b/tasks/0063_243_63243800_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..82042c39de4de4b3f3bb46f17e13acce2fb7a0f9
--- /dev/null
+++ b/tasks/0063_243_63243800_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the cumulative percentage of variance explained by the first 17 Principal Components after PCA decomposition of the standardized dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0063_243_63243800_qa_2/task.toml b/tasks/0063_243_63243800_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5d867676d923984a1b7dfcd47a2e5ccfe33c14c3
--- /dev/null
+++ b/tasks/0063_243_63243800_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0063_243_63243800_qa_2"
+description = "What is the cumulative percentage of variance explained by the first 17 Principal Components after PCA decomposition of the standardized dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0063/243/63243800.ipynb_qa_2"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "99.18"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "99.18"
+QUESTION = "What is the cumulative percentage of variance explained by the first 17 Principal Components after PCA decomposition of the standardized dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0063_399_63399748_qa_5/instruction.md b/tasks/0063_399_63399748_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a8f086f9184968dc409cf5b9be78512beab07cdf
--- /dev/null
+++ b/tasks/0063_399_63399748_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the range of the "area_mean" feature in the dataset (difference between maximum and minimum values)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0063_399_63399748_qa_5/task.toml b/tasks/0063_399_63399748_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..763c564a954257d8a2e7c5d7935553561cbb0f0b
--- /dev/null
+++ b/tasks/0063_399_63399748_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0063_399_63399748_qa_5"
+description = "What is the range of the \"area_mean\" feature in the dataset (difference between maximum and minimum values)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0063/399/63399748.ipynb_qa_5"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "2357.5"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2357.5"
+QUESTION = "What is the range of the \"area_mean\" feature in the dataset (difference between maximum and minimum values)?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0063_842_63842304_qa_4/instruction.md b/tasks/0063_842_63842304_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..728f31743328af0a9fcf49c07e2cf8169d40a7d1
--- /dev/null
+++ b/tasks/0063_842_63842304_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- sonar.all-data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many samples in the dataset are classified as Mines (M)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0063_842_63842304_qa_4/task.toml b/tasks/0063_842_63842304_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7cabe77ff1adf20b3bb0f0c04b60c6baff18f148
--- /dev/null
+++ b/tasks/0063_842_63842304_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0063_842_63842304_qa_4"
+description = "How many samples in the dataset are classified as Mines (M)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0063/842/63842304.ipynb_qa_4"
+kaggle_dataset_name = "mattcarter865/mines-vs-rocks"
+gold_answer = "111"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mattcarter865__mines-vs-rocks"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mattcarter865/mines-vs-rocks"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "111"
+QUESTION = "How many samples in the dataset are classified as Mines (M)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0063_914_63914761_qa_4/instruction.md b/tasks/0063_914_63914761_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f452e89ea110b893821429bbd6b63bcf1b2cc22f
--- /dev/null
+++ b/tasks/0063_914_63914761_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which country has the highest total number of orders (measured by quantity) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0063_914_63914761_qa_4/task.toml b/tasks/0063_914_63914761_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..28db5f51118608b99170907b3ca1e644ab802159
--- /dev/null
+++ b/tasks/0063_914_63914761_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0063_914_63914761_qa_4"
+description = "Which country has the highest total number of orders (measured by quantity) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0063/914/63914761.ipynb_qa_4"
+kaggle_dataset_name = "carrie1/ecommerce-data"
+gold_answer = "United Kingdom"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "carrie1__ecommerce-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "carrie1/ecommerce-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "United Kingdom"
+QUESTION = "Which country has the highest total number of orders (measured by quantity) in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0064_908_64908177_qa_2/instruction.md b/tasks/0064_908_64908177_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5efa6f93dae766e7c3d0b25d5406420c9f8337bb
--- /dev/null
+++ b/tasks/0064_908_64908177_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most important variable in the TF-DF Random Forest model based on the "NUM_NODES" variable importance metric?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0064_908_64908177_qa_2/task.toml b/tasks/0064_908_64908177_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..98078d60062c288b0df87f7367c77170691dce79
--- /dev/null
+++ b/tasks/0064_908_64908177_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0064_908_64908177_qa_2"
+description = "What is the most important variable in the TF-DF Random Forest model based on the \"NUM_NODES\" variable importance metric?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0064/908/64908177.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "What is the most important variable in the TF-DF Random Forest model based on the \"NUM_NODES\" variable importance metric?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0065_282_65282332_qa_2/instruction.md b/tasks/0065_282_65282332_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a45a65b1222af8b392dfbc6de794575e22092896
--- /dev/null
+++ b/tasks/0065_282_65282332_qa_2/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Train.csv
+- Test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most important feature for predicting Item_Outlet_Sales according to the ExtraTreesRegressor feature importance analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0065_282_65282332_qa_2/task.toml b/tasks/0065_282_65282332_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9e1faddd5f2e1c0934d634e3dc485744814ff244
--- /dev/null
+++ b/tasks/0065_282_65282332_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0065_282_65282332_qa_2"
+description = "What is the most important feature for predicting Item_Outlet_Sales according to the ExtraTreesRegressor feature importance analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0065/282/65282332.ipynb_qa_2"
+kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data"
+gold_answer = "Item_MRP"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Item_MRP"
+QUESTION = "What is the most important feature for predicting Item_Outlet_Sales according to the ExtraTreesRegressor feature importance analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0065_573_65573990_qa_5/instruction.md b/tasks/0065_573_65573990_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b23f2f39ddf0398c2e0fbaf79dbac0d65e10f1ce
--- /dev/null
+++ b/tasks/0065_573_65573990_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest overall accuracy achieved by any model on the test set?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0065_573_65573990_qa_5/task.toml b/tasks/0065_573_65573990_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c890ba570904eb270fd912353206e6c55c5f4ce7
--- /dev/null
+++ b/tasks/0065_573_65573990_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0065_573_65573990_qa_5"
+description = "What is the highest overall accuracy achieved by any model on the test set?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0065/573/65573990.ipynb_qa_5"
+kaggle_dataset_name = "team-ai/spam-text-message-classification"
+gold_answer = "98"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "team-ai__spam-text-message-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "team-ai/spam-text-message-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "98"
+QUESTION = "What is the highest overall accuracy achieved by any model on the test set?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0065_789_65789409_qa_2/instruction.md b/tasks/0065_789_65789409_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3f2c947347efe0587791fc0ec5c80f0883fb1e59
--- /dev/null
+++ b/tasks/0065_789_65789409_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the top feature identified by XGBoost's feature importance analysis for predicting log_price?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0065_789_65789409_qa_2/task.toml b/tasks/0065_789_65789409_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4dcbc7ab8d5fe8e9c224e3fe5776de7fe9ff27d0
--- /dev/null
+++ b/tasks/0065_789_65789409_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0065_789_65789409_qa_2"
+description = "What is the top feature identified by XGBoost's feature importance analysis for predicting log_price?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0065/789/65789409.ipynb_qa_2"
+kaggle_dataset_name = "stevezhenghp/airbnb-price-prediction"
+gold_answer = "room_type"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "stevezhenghp__airbnb-price-prediction"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "stevezhenghp/airbnb-price-prediction"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "room_type"
+QUESTION = "What is the top feature identified by XGBoost's feature importance analysis for predicting log_price?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0066_039_66039698_qa_2/instruction.md b/tasks/0066_039_66039698_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d862b327bdd29a7c8f9fa0cfdc91074406cc74f2
--- /dev/null
+++ b/tasks/0066_039_66039698_qa_2/instruction.md
@@ -0,0 +1,25 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- 2007.csv
+- 2008.csv
+- 2009.csv
+- 2010.csv
+- 2011.csv
+- 2012.csv
+- 2013.csv
+- 2014.csv
+- 2015.csv
+- 2016.csv
+- 2017.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+By how many percentage points did the popularity of Labrador Retrievers decrease from 2008 to 2009?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0066_039_66039698_qa_2/task.toml b/tasks/0066_039_66039698_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4a9bbaa65dc50465c3b26b1c3fcbd9a398f2b4f6
--- /dev/null
+++ b/tasks/0066_039_66039698_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0066_039_66039698_qa_2"
+description = "By how many percentage points did the popularity of Labrador Retrievers decrease from 2008 to 2009?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0066/039/66039698.ipynb_qa_2"
+kaggle_dataset_name = "kingburrito666/largest-dog-breed-data-set"
+gold_answer = "-0.509763"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kingburrito666__largest-dog-breed-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kingburrito666/largest-dog-breed-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.509763"
+QUESTION = "By how many percentage points did the popularity of Labrador Retrievers decrease from 2008 to 2009?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0066_039_66039698_qa_4/instruction.md b/tasks/0066_039_66039698_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fa0c7fe7b65ba700c7dee64e8d689ee8050134f9
--- /dev/null
+++ b/tasks/0066_039_66039698_qa_4/instruction.md
@@ -0,0 +1,27 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- 2007.csv
+- 2008.csv
+- 2009.csv
+- 2010.csv
+- 2011.csv
+- 2012.csv
+- 2013.csv
+- 2014.csv
+- 2015.csv
+- 2016.csv
+- 2017.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common dog name in 2017, and how many times was it used?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <name>, <count> (comma-separated, name first, count as a plain number).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0066_039_66039698_qa_4/task.toml b/tasks/0066_039_66039698_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..701fb88688dca41a595b3810a757c441dbd7537c
--- /dev/null
+++ b/tasks/0066_039_66039698_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0066_039_66039698_qa_4"
+description = "What is the most common dog name in 2017, and how many times was it used?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0066/039/66039698.ipynb_qa_4"
+kaggle_dataset_name = "kingburrito666/largest-dog-breed-data-set"
+gold_answer = "BELLA, 342"
+reward_mode_initial = "list"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kingburrito666__largest-dog-breed-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kingburrito666/largest-dog-breed-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "BELLA, 342"
+QUESTION = "What is the most common dog name in 2017, and how many times was it used?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0066_392_66392992_qa_3/instruction.md b/tasks/0066_392_66392992_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b128083945a0d07d5caa035e38177badafc32141
--- /dev/null
+++ b/tasks/0066_392_66392992_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- database.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which cluster's centroid has the most negative longitude value, and what is that value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0066_392_66392992_qa_3/task.toml b/tasks/0066_392_66392992_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5f95711e48da8a1048c23b8ceba64615790854e7
--- /dev/null
+++ b/tasks/0066_392_66392992_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0066_392_66392992_qa_3"
+description = "Which cluster's centroid has the most negative longitude value, and what is that value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0066/392/66392992.ipynb_qa_3"
+kaggle_dataset_name = "smithsonian/volcanic-eruptions"
+gold_answer = "-145.43676549"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "smithsonian__volcanic-eruptions"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "smithsonian/volcanic-eruptions"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-145.43676549"
+QUESTION = "Which cluster's centroid has the most negative longitude value, and what is that value?"
+REWARD_MODE = "flexible"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0067_118_67118977_qa_5/instruction.md b/tasks/0067_118_67118977_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..015a0ecb483413e42a34738d9a86e89e0ed4ad61
--- /dev/null
+++ b/tasks/0067_118_67118977_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest frequency of any wine quality rating in the original dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0067_118_67118977_qa_5/task.toml b/tasks/0067_118_67118977_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d8bb62519312347905d0d06973ba5fa46a22bf96
--- /dev/null
+++ b/tasks/0067_118_67118977_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0067_118_67118977_qa_5"
+description = "What is the highest frequency of any wine quality rating in the original dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0067/118/67118977.ipynb_qa_5"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "681"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "681"
+QUESTION = "What is the highest frequency of any wine quality rating in the original dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0067_446_67446851_qa_1/instruction.md b/tasks/0067_446_67446851_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..dc51aed2d38a3e392ebf1baefd9084b91f6a6626
--- /dev/null
+++ b/tasks/0067_446_67446851_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature shows the least separation between benign and malignant classes according to the box plot analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0067_446_67446851_qa_1/task.toml b/tasks/0067_446_67446851_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..96236cc0441d36fd8d2ae104ce228e5f37298fa0
--- /dev/null
+++ b/tasks/0067_446_67446851_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0067_446_67446851_qa_1"
+description = "Which feature shows the least separation between benign and malignant classes according to the box plot analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0067/446/67446851.ipynb_qa_1"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "fractal_dimension_mean"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "fractal_dimension_mean"
+QUESTION = "Which feature shows the least separation between benign and malignant classes according to the box plot analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0067_511_67511593_qa_2/instruction.md b/tasks/0067_511_67511593_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..283a90e12f45779b13fa529c1b2ad2c4b7e73f70
--- /dev/null
+++ b/tasks/0067_511_67511593_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of data points identified as outliers in the SepalWidthCm feature based on the specified thresholds (greater than 4.0 and less than 2.05)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0067_511_67511593_qa_2/task.toml b/tasks/0067_511_67511593_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..69057ad50384301d534b6ae76864031855f2e60f
--- /dev/null
+++ b/tasks/0067_511_67511593_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0067_511_67511593_qa_2"
+description = "What is the total number of data points identified as outliers in the SepalWidthCm feature based on the specified thresholds (greater than 4.0 and less than 2.05)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0067/511/67511593.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "4"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4"
+QUESTION = "What is the total number of data points identified as outliers in the SepalWidthCm feature based on the specified thresholds (greater than 4.0 and less than 2.05)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0067_522_67522470_qa_4/instruction.md b/tasks/0067_522_67522470_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..818cdc1574e80aebdf05b430cf219ff921a72a87
--- /dev/null
+++ b/tasks/0067_522_67522470_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+According to the descriptive statistics, what is the difference between the 75th percentile of Sepal Length (6.40 cm) and Petal Length (5.10 cm) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0067_522_67522470_qa_4/task.toml b/tasks/0067_522_67522470_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f27ff3eab9b7909b49e57fa1bd3a242321576ecb
--- /dev/null
+++ b/tasks/0067_522_67522470_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0067_522_67522470_qa_4"
+description = "According to the descriptive statistics, what is the difference between the 75th percentile of Sepal Length (6.40 cm) and Petal Length (5.10 cm) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0067/522/67522470.ipynb_qa_4"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "1.30"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.30"
+QUESTION = "According to the descriptive statistics, what is the difference between the 75th percentile of Sepal Length (6.40 cm) and Petal Length (5.10 cm) in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0068_041_68041367_qa_2/instruction.md b/tasks/0068_041_68041367_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b4af62f380e095ca61b36e0f146ba8197b25090c
--- /dev/null
+++ b/tasks/0068_041_68041367_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of patients in the dataset are diabetic (Outcome = 1)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0068_041_68041367_qa_2/task.toml b/tasks/0068_041_68041367_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..609ff1ebd89d6a9653671a7b0c7a8d63a5989330
--- /dev/null
+++ b/tasks/0068_041_68041367_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0068_041_68041367_qa_2"
+description = "What percentage of patients in the dataset are diabetic (Outcome = 1)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0068/041/68041367.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "34.9"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "34.9"
+QUESTION = "What percentage of patients in the dataset are diabetic (Outcome = 1)?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0068_041_68041367_qa_5/instruction.md b/tasks/0068_041_68041367_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cc48ae4f855c5fa71c61508f44745ba00c591ece
--- /dev/null
+++ b/tasks/0068_041_68041367_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the F1-score for diabetic patients (Outcome = 1) in the model's predictions?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0068_041_68041367_qa_5/task.toml b/tasks/0068_041_68041367_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b94c604aba37b75a4f74abb683de88d8de45247f
--- /dev/null
+++ b/tasks/0068_041_68041367_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0068_041_68041367_qa_5"
+description = "What is the F1-score for diabetic patients (Outcome = 1) in the model's predictions?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0068/041/68041367.ipynb_qa_5"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "0.62"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.62"
+QUESTION = "What is the F1-score for diabetic patients (Outcome = 1) in the model's predictions?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0068_864_68864400_qa_1/instruction.md b/tasks/0068_864_68864400_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f25d441b88686a09b0b3d31bfcddb4ce437c87f5
--- /dev/null
+++ b/tasks/0068_864_68864400_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the percentage of missing values (encoded as 0) in the 'Insulin' column before imputation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0068_864_68864400_qa_1/task.toml b/tasks/0068_864_68864400_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..33cd530195e5c1a3631ed1dbf6cfa6d6fa92eb00
--- /dev/null
+++ b/tasks/0068_864_68864400_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0068_864_68864400_qa_1"
+description = "What is the percentage of missing values (encoded as 0) in the 'Insulin' column before imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0068/864/68864400.ipynb_qa_1"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "48.7"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "48.7"
+QUESTION = "What is the percentage of missing values (encoded as 0) in the 'Insulin' column before imputation?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0068_964_68964852_qa_2/instruction.md b/tasks/0068_964_68964852_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8c2ab070fe929822ab64fe5e5221687fe58550f5
--- /dev/null
+++ b/tasks/0068_964_68964852_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest accuracy achieved by the KNN model on the test set when using the optimal K value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0068_964_68964852_qa_2/task.toml b/tasks/0068_964_68964852_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..47c7c1b3e84924e280b26bfb3ff175836cedb00f
--- /dev/null
+++ b/tasks/0068_964_68964852_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0068_964_68964852_qa_2"
+description = "What is the highest accuracy achieved by the KNN model on the test set when using the optimal K value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0068/964/68964852.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "1.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.0"
+QUESTION = "What is the highest accuracy achieved by the KNN model on the test set when using the optimal K value?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0069_000_69000693_qa_5/instruction.md b/tasks/0069_000_69000693_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..551ebc47888897fd198223bb76137f3db02339ca
--- /dev/null
+++ b/tasks/0069_000_69000693_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many messages are classified as ham and spam in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+: Answer as comma-separated <label>:<count> pairs, label first, counts as plain numbers.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0069_000_69000693_qa_5/task.toml b/tasks/0069_000_69000693_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..539a0207cfd8cc069f99103a218bd7b60592727b
--- /dev/null
+++ b/tasks/0069_000_69000693_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0069_000_69000693_qa_5"
+description = "How many messages are classified as ham and spam in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0069/000/69000693.ipynb_qa_5"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "4825 ham, 747 spam"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4825 ham, 747 spam"
+QUESTION = "How many messages are classified as ham and spam in the dataset?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0069_094_69094334_qa_4/instruction.md b/tasks/0069_094_69094334_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6b8a3971e27d6a3ad9ffcbf366a6c3ae908f45b9
--- /dev/null
+++ b/tasks/0069_094_69094334_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- ionosphere_data_kaggle.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the F1-score of the Logistic Regression model on the test set without applying PCA?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0069_094_69094334_qa_4/task.toml b/tasks/0069_094_69094334_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..84dd743a34326e4f41e4a79ca600ac4cabe53461
--- /dev/null
+++ b/tasks/0069_094_69094334_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0069_094_69094334_qa_4"
+description = "What is the F1-score of the Logistic Regression model on the test set without applying PCA?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0069/094/69094334.ipynb_qa_4"
+kaggle_dataset_name = "creepyghost/uci-ionosphere"
+gold_answer = "0.914"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "creepyghost__uci-ionosphere"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "creepyghost/uci-ionosphere"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.914"
+QUESTION = "What is the F1-score of the Logistic Regression model on the test set without applying PCA?"
+REWARD_MODE = "flexible"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0069_399_69399288_qa_4/instruction.md b/tasks/0069_399_69399288_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..35f679a694a1341c3caed757463adaa9ee523658
--- /dev/null
+++ b/tasks/0069_399_69399288_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many false negatives are present in the test set predictions according to the confusion matrix?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0069_399_69399288_qa_4/task.toml b/tasks/0069_399_69399288_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..87d724bb1c34372b8a83fc3b13c626b94b593418
--- /dev/null
+++ b/tasks/0069_399_69399288_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0069_399_69399288_qa_4"
+description = "How many false negatives are present in the test set predictions according to the confusion matrix?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0069/399/69399288.ipynb_qa_4"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "2"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2"
+QUESTION = "How many false negatives are present in the test set predictions according to the confusion matrix?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0069_698_69698122_qa_4/instruction.md b/tasks/0069_698_69698122_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d995991c48ba9e5ab83370cbe1770ae4a9c75dac
--- /dev/null
+++ b/tasks/0069_698_69698122_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many instances remain in the dataset after removing rows with missing values?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0069_698_69698122_qa_4/task.toml b/tasks/0069_698_69698122_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2277d0f1e82a7d812aa7afb318651c654224e631
--- /dev/null
+++ b/tasks/0069_698_69698122_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0069_698_69698122_qa_4"
+description = "How many instances remain in the dataset after removing rows with missing values?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0069/698/69698122.ipynb_qa_4"
+kaggle_dataset_name = "wenruliu/adult-income-dataset"
+gold_answer = "45222"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "wenruliu__adult-income-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "wenruliu/adult-income-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "45222"
+QUESTION = "How many instances remain in the dataset after removing rows with missing values?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0069_956_69956218_qa_3/instruction.md b/tasks/0069_956_69956218_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6529e2ac35e7b26b403ec30d2ac6ccf08d9a305a
--- /dev/null
+++ b/tasks/0069_956_69956218_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+For the RM column, which transformation (Box-Cox or Yeo-Johnson) produces a more normally distributed result based on the skewness value, and what is the skewness after applying that method?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <transformation>, <skewness> (comma-separated, label first, keep decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0069_956_69956218_qa_3/task.toml b/tasks/0069_956_69956218_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a299bc39044f6c2d411ba900606569e156c1cdb4
--- /dev/null
+++ b/tasks/0069_956_69956218_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0069_956_69956218_qa_3"
+description = "For the RM column, which transformation (Box-Cox or Yeo-Johnson) produces a more normally distributed result based on the skewness value, and what is the skewness after applying that method?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0069/956/69956218.ipynb_qa_3"
+kaggle_dataset_name = "schirmerchad/bostonhoustingmlnd"
+gold_answer = "Yeo-Johnson, 0.06"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "schirmerchad__bostonhoustingmlnd"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "schirmerchad/bostonhoustingmlnd"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Yeo-Johnson, 0.06"
+QUESTION = "For the RM column, which transformation (Box-Cox or Yeo-Johnson) produces a more normally distributed result based on the skewness value, and what is the skewness after applying that method?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0070_620_70620378_qa_5/instruction.md b/tasks/0070_620_70620378_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac5b646e3b435901cb34d76d7205ce4227852d47
--- /dev/null
+++ b/tasks/0070_620_70620378_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the retention rate for the 2010-12-01 cohort in the 12th month after their first purchase?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0070_620_70620378_qa_5/task.toml b/tasks/0070_620_70620378_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..874baa79b1097b62999a0acd35b322e42174fd1e
--- /dev/null
+++ b/tasks/0070_620_70620378_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0070_620_70620378_qa_5"
+description = "What is the retention rate for the 2010-12-01 cohort in the 12th month after their first purchase?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0070/620/70620378.ipynb_qa_5"
+kaggle_dataset_name = "carrie1/ecommerce-data"
+gold_answer = "50"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "carrie1__ecommerce-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "carrie1/ecommerce-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "50"
+QUESTION = "What is the retention rate for the 2010-12-01 cohort in the 12th month after their first purchase?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0070_816_70816004_qa_3/instruction.md b/tasks/0070_816_70816004_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c4678e961588f2f5c88a2db9baab708a9b2b6482
--- /dev/null
+++ b/tasks/0070_816_70816004_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many features are used as input for the decision tree model in the wine quality classification task?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0070_816_70816004_qa_3/task.toml b/tasks/0070_816_70816004_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2cacf95f1084146dae205f376e43a382404831f2
--- /dev/null
+++ b/tasks/0070_816_70816004_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0070_816_70816004_qa_3"
+description = "How many features are used as input for the decision tree model in the wine quality classification task?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0070/816/70816004.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "11"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "11"
+QUESTION = "How many features are used as input for the decision tree model in the wine quality classification task?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0071_091_71091389_qa_2/instruction.md b/tasks/0071_091_71091389_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..10f5287db17005c0b125b18fc651165a8ad31757
--- /dev/null
+++ b/tasks/0071_091_71091389_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- kc_house_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the R² score of the linear regression model using the 'sqft_living' feature compared to the model using the 11 most correlated features (floors, waterfront, lat, bedrooms, sqft_basement, view, bathrooms, sqft_living15, sqft_above, grade, sqft_living)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of two values, in the order given: <r2_sqft_living>, <r2_11_features>, each as a plain number with six decimals.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0071_091_71091389_qa_2/task.toml b/tasks/0071_091_71091389_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5ae0c2b888b156df1a96de974d87e2b76cd2b058
--- /dev/null
+++ b/tasks/0071_091_71091389_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0071_091_71091389_qa_2"
+description = "What is the R² score of the linear regression model using the 'sqft_living' feature compared to the model using the 11 most correlated features (floors, waterfront, lat, bedrooms, sqft_basement, view, bathrooms, sqft_living15, sqft_above, grade, sqft_living)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0071/091/71091389.ipynb_qa_2"
+kaggle_dataset_name = "harlfoxem/housesalesprediction"
+gold_answer = "0.492853, 0.657715"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "harlfoxem__housesalesprediction"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.492853, 0.657715"
+QUESTION = "What is the R² score of the linear regression model using the 'sqft_living' feature compared to the model using the 11 most correlated features (floors, waterfront, lat, bedrooms, sqft_basement, view, bathrooms, sqft_living15, sqft_above, grade, sqft_living)?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0071_397_71397798_qa_2/instruction.md b/tasks/0071_397_71397798_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..24df0b05a11dbee22f98bb5189bf2a2a304e4f9e
--- /dev/null
+++ b/tasks/0071_397_71397798_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many additional text samples were incorporated into the dataset by extracting non-null values from the Unnamed columns?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0071_397_71397798_qa_2/task.toml b/tasks/0071_397_71397798_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fd1028a9c7be185aaf9204045656fc1b56657364
--- /dev/null
+++ b/tasks/0071_397_71397798_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0071_397_71397798_qa_2"
+description = "How many additional text samples were incorporated into the dataset by extracting non-null values from the Unnamed columns?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0071/397/71397798.ipynb_qa_2"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "68"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "68"
+QUESTION = "How many additional text samples were incorporated into the dataset by extracting non-null values from the Unnamed columns?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0071_909_71909129_qa_2/instruction.md b/tasks/0071_909_71909129_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..860e882c45b1635f7508e6a049c07f2ba6078cd7
--- /dev/null
+++ b/tasks/0071_909_71909129_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which gaming platform generated the highest total sales specifically in the Japanese market (JP_Sales)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0071_909_71909129_qa_2/task.toml b/tasks/0071_909_71909129_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f1699dba533ade336ddb8c6f201b38b52e3a92f1
--- /dev/null
+++ b/tasks/0071_909_71909129_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0071_909_71909129_qa_2"
+description = "Which gaming platform generated the highest total sales specifically in the Japanese market (JP_Sales)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0071/909/71909129.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "DS"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "DS"
+QUESTION = "Which gaming platform generated the highest total sales specifically in the Japanese market (JP_Sales)?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0071_997_71997138_qa_3/instruction.md b/tasks/0071_997_71997138_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cf4235078eae905d0fb76da3d38c677a52b300f0
--- /dev/null
+++ b/tasks/0071_997_71997138_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Advertising.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+According to the multiple regression analysis, which advertising channel does not have a statistically significant effect on sales at the 5% significance level?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0071_997_71997138_qa_3/task.toml b/tasks/0071_997_71997138_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f3a775d2346f13317dd077b3fa9509701ad2731e
--- /dev/null
+++ b/tasks/0071_997_71997138_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0071_997_71997138_qa_3"
+description = "According to the multiple regression analysis, which advertising channel does not have a statistically significant effect on sales at the 5% significance level?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0071/997/71997138.ipynb_qa_3"
+kaggle_dataset_name = "purbar/advertising-data"
+gold_answer = "Newspaper"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "purbar__advertising-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "purbar/advertising-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Newspaper"
+QUESTION = "According to the multiple regression analysis, which advertising channel does not have a statistically significant effect on sales at the 5% significance level?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0071_997_71997138_qa_5/instruction.md b/tasks/0071_997_71997138_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9891ed6e8ae6b87ad8498f66f501cb688bef1c28
--- /dev/null
+++ b/tasks/0071_997_71997138_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Advertising.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the estimated change in sales associated with a one-unit increase in Radio advertising expenditure, holding all other variables constant, according to the multiple regression model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0071_997_71997138_qa_5/task.toml b/tasks/0071_997_71997138_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d24af05063b2f4f771fbf0a52c6e7d2b9c508ec1
--- /dev/null
+++ b/tasks/0071_997_71997138_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0071_997_71997138_qa_5"
+description = "What is the estimated change in sales associated with a one-unit increase in Radio advertising expenditure, holding all other variables constant, according to the multiple regression model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0071/997/71997138.ipynb_qa_5"
+kaggle_dataset_name = "purbar/advertising-data"
+gold_answer = "0.1885"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "purbar__advertising-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "purbar/advertising-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.1885"
+QUESTION = "What is the estimated change in sales associated with a one-unit increase in Radio advertising expenditure, holding all other variables constant, according to the multiple regression model?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0072_403_72403187_qa_1/instruction.md b/tasks/0072_403_72403187_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5ca318817bb0f68219f3958b4dd29b04ef14b9e1
--- /dev/null
+++ b/tasks/0072_403_72403187_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the dataset has the highest Variance Inflation Factor (VIF), indicating severe multicollinearity?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0072_403_72403187_qa_1/task.toml b/tasks/0072_403_72403187_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0d4840d86c42dbff8df1cd73c7923bc572b73d0d
--- /dev/null
+++ b/tasks/0072_403_72403187_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0072_403_72403187_qa_1"
+description = "Which feature in the dataset has the highest Variance Inflation Factor (VIF), indicating severe multicollinearity?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0072/403/72403187.ipynb_qa_1"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "radius_mean"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "radius_mean"
+QUESTION = "Which feature in the dataset has the highest Variance Inflation Factor (VIF), indicating severe multicollinearity?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0072_665_72665847_qa_5/instruction.md b/tasks/0072_665_72665847_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..173809d5b2c168b08c44d04550c8201b3aa3819f
--- /dev/null
+++ b/tasks/0072_665_72665847_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- bank.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which education level shows the highest deposit rate according to the dataset analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0072_665_72665847_qa_5/task.toml b/tasks/0072_665_72665847_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6b764b058ccfa014e03b0557a0ed72b9d2eb6431
--- /dev/null
+++ b/tasks/0072_665_72665847_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0072_665_72665847_qa_5"
+description = "Which education level shows the highest deposit rate according to the dataset analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0072/665/72665847.ipynb_qa_5"
+kaggle_dataset_name = "janiobachmann/bank-marketing-dataset"
+gold_answer = "Tertiary"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "janiobachmann__bank-marketing-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Tertiary"
+QUESTION = "Which education level shows the highest deposit rate according to the dataset analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0073_125_73125764_qa_5/instruction.md b/tasks/0073_125_73125764_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..55503f71b72258f69263448f52209cef972c03a6
--- /dev/null
+++ b/tasks/0073_125_73125764_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many missing values were present in the 'Body' column before imputation was applied?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0073_125_73125764_qa_5/task.toml b/tasks/0073_125_73125764_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2942718682f9e26dd96b61ee53f3b3ae050cc946
--- /dev/null
+++ b/tasks/0073_125_73125764_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0073_125_73125764_qa_5"
+description = "How many missing values were present in the 'Body' column before imputation was applied?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0073/125/73125764.ipynb_qa_5"
+kaggle_dataset_name = "jruvika/fake-news-detection"
+gold_answer = "21"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "jruvika__fake-news-detection"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jruvika/fake-news-detection"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "21"
+QUESTION = "How many missing values were present in the 'Body' column before imputation was applied?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0073_798_73798390_qa_4/instruction.md b/tasks/0073_798_73798390_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..00c8a9b78f57e217510c1193cf031c6a1456f101
--- /dev/null
+++ b/tasks/0073_798_73798390_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- HR_comma_sep.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the precision score for predicting employees who left (class 1) in the Decision Tree model evaluation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0073_798_73798390_qa_4/task.toml b/tasks/0073_798_73798390_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..47529cb1e4cad30aeb9763ab6cb7a5edc2fcc01b
--- /dev/null
+++ b/tasks/0073_798_73798390_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0073_798_73798390_qa_4"
+description = "What is the precision score for predicting employees who left (class 1) in the Decision Tree model evaluation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0073/798/73798390.ipynb_qa_4"
+kaggle_dataset_name = "giripujar/hr-analytics"
+gold_answer = "0.95"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "giripujar__hr-analytics"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "giripujar/hr-analytics"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.95"
+QUESTION = "What is the precision score for predicting employees who left (class 1) in the Decision Tree model evaluation?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0073_814_73814551_qa_3/instruction.md b/tasks/0073_814_73814551_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..11ca1fc07fc7419de3046a9da6d447571e874125
--- /dev/null
+++ b/tasks/0073_814_73814551_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- bank.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average age of customers who subscribed to a term deposit in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0073_814_73814551_qa_3/task.toml b/tasks/0073_814_73814551_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0adf9d47c61a63e29df3cf66184b74a5e77cd9c3
--- /dev/null
+++ b/tasks/0073_814_73814551_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0073_814_73814551_qa_3"
+description = "What is the average age of customers who subscribed to a term deposit in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0073/814/73814551.ipynb_qa_3"
+kaggle_dataset_name = "janiobachmann/bank-marketing-dataset"
+gold_answer = "41.67"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "janiobachmann__bank-marketing-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "41.67"
+QUESTION = "What is the average age of customers who subscribed to a term deposit in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0073_893_73893447_qa_1/instruction.md b/tasks/0073_893_73893447_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4bf1ad92c8707fe4e1dc32e1149db2a20659dde4
--- /dev/null
+++ b/tasks/0073_893_73893447_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the percentage of customers who defaulted on their payment in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0073_893_73893447_qa_1/task.toml b/tasks/0073_893_73893447_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..156565b4c9ef3c51eb0ea5849271c198fff78c2a
--- /dev/null
+++ b/tasks/0073_893_73893447_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0073_893_73893447_qa_1"
+description = "What is the percentage of customers who defaulted on their payment in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0073/893/73893447.ipynb_qa_1"
+kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset"
+gold_answer = "22"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__default-of-credit-card-clients-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "22"
+QUESTION = "What is the percentage of customers who defaulted on their payment in the dataset?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0073_939_73939724_qa_1/instruction.md b/tasks/0073_939_73939724_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e09fd74a6e7a82dfb8be0fb353fae48bc364ce2
--- /dev/null
+++ b/tasks/0073_939_73939724_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diamonds.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which diamond cut type has the highest median price according to the dataset analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0073_939_73939724_qa_1/task.toml b/tasks/0073_939_73939724_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..93c37e8d02f06643fb4fd647c3b5cc61cd257495
--- /dev/null
+++ b/tasks/0073_939_73939724_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0073_939_73939724_qa_1"
+description = "Which diamond cut type has the highest median price according to the dataset analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0073/939/73939724.ipynb_qa_1"
+kaggle_dataset_name = "shivam2503/diamonds"
+gold_answer = "Fair"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "shivam2503__diamonds"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "shivam2503/diamonds"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Fair"
+QUESTION = "Which diamond cut type has the highest median price according to the dataset analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0073_984_73984919_qa_4/instruction.md b/tasks/0073_984_73984919_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d4004e0178db9f9684d5a1d43cfaf229adfc9b0e
--- /dev/null
+++ b/tasks/0073_984_73984919_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- german_credit_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of the dataset is classified as having 'good' credit risk?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0073_984_73984919_qa_4/task.toml b/tasks/0073_984_73984919_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..00a83f1465d6e5fd436241f78fc34830787ba6b5
--- /dev/null
+++ b/tasks/0073_984_73984919_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0073_984_73984919_qa_4"
+description = "What percentage of the dataset is classified as having 'good' credit risk?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0073/984/73984919.ipynb_qa_4"
+kaggle_dataset_name = "kabure/german-credit-data-with-risk"
+gold_answer = "70"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kabure__german-credit-data-with-risk"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kabure/german-credit-data-with-risk"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "70"
+QUESTION = "What percentage of the dataset is classified as having 'good' credit risk?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0074_450_74450579_qa_5/instruction.md b/tasks/0074_450_74450579_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..19c22587462d5c1de4e3510afcd05844f9ce9190
--- /dev/null
+++ b/tasks/0074_450_74450579_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- indian_liver_patient.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Is the correlation matrix of quantitative variables in the cleaned dataset statistically significantly different from an identity matrix according to Bartlett's test?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0074_450_74450579_qa_5/task.toml b/tasks/0074_450_74450579_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5cf4fd0ad5ecca5a418538760a42e47b630dcb54
--- /dev/null
+++ b/tasks/0074_450_74450579_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0074_450_74450579_qa_5"
+description = "Is the correlation matrix of quantitative variables in the cleaned dataset statistically significantly different from an identity matrix according to Bartlett's test?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0074/450/74450579.ipynb_qa_5"
+kaggle_dataset_name = "uciml/indian-liver-patient-records"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__indian-liver-patient-records"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/indian-liver-patient-records"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Is the correlation matrix of quantitative variables in the cleaned dataset statistically significantly different from an identity matrix according to Bartlett's test?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0074_467_74467849_qa_1/instruction.md b/tasks/0074_467_74467849_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..72da4ad031242f0063f2a4029bf466e6ff52b86c
--- /dev/null
+++ b/tasks/0074_467_74467849_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- student-mat.csv
+- student-por.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest mutual information score with the final grade (G3) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0074_467_74467849_qa_1/task.toml b/tasks/0074_467_74467849_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2af6d9ef42d9cebae7069fe05ea2ae866f4c29f9
--- /dev/null
+++ b/tasks/0074_467_74467849_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0074_467_74467849_qa_1"
+description = "Which feature has the highest mutual information score with the final grade (G3) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0074/467/74467849.ipynb_qa_1"
+kaggle_dataset_name = "uciml/student-alcohol-consumption"
+gold_answer = "G2"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__student-alcohol-consumption"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "G2"
+QUESTION = "Which feature has the highest mutual information score with the final grade (G3) in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0074_537_74537408_qa_5/instruction.md b/tasks/0074_537_74537408_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b2202bfbbb90795664052aed1d94540b584c111f
--- /dev/null
+++ b/tasks/0074_537_74537408_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- KaggleV2-May-2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the percentage of patients who are female?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0074_537_74537408_qa_5/task.toml b/tasks/0074_537_74537408_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9cdf1e55e48c1bea42c74152bc24b3aebf8ff775
--- /dev/null
+++ b/tasks/0074_537_74537408_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0074_537_74537408_qa_5"
+description = "What is the percentage of patients who are female?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0074/537/74537408.ipynb_qa_5"
+kaggle_dataset_name = "joniarroba/noshowappointments"
+gold_answer = "65"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "joniarroba__noshowappointments"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "joniarroba/noshowappointments"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "65"
+QUESTION = "What is the percentage of patients who are female?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0074_836_74836808_qa_3/instruction.md b/tasks/0074_836_74836808_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..95be36808d3870bbc2a329162b3ba687d4f54396
--- /dev/null
+++ b/tasks/0074_836_74836808_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- KaggleV2-May-2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which neighborhood has the highest frequency of scheduled medical appointments in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0074_836_74836808_qa_3/task.toml b/tasks/0074_836_74836808_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ecc0ab14d0cdd4c92330747d63b543c5592ff8ab
--- /dev/null
+++ b/tasks/0074_836_74836808_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0074_836_74836808_qa_3"
+description = "Which neighborhood has the highest frequency of scheduled medical appointments in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0074/836/74836808.ipynb_qa_3"
+kaggle_dataset_name = "joniarroba/noshowappointments"
+gold_answer = "JARDIM CAMBURI"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "joniarroba__noshowappointments"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "joniarroba/noshowappointments"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "JARDIM CAMBURI"
+QUESTION = "Which neighborhood has the highest frequency of scheduled medical appointments in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0074_845_74845042_qa_5/instruction.md b/tasks/0074_845_74845042_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e755c6733ec4677b4959bd13f3033155f4982c5e
--- /dev/null
+++ b/tasks/0074_845_74845042_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- auto-mpg.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of samples and features in the preprocessed dataset used for modeling?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <total_samples>, <total_features> (comma-separated, numbers only).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0074_845_74845042_qa_5/task.toml b/tasks/0074_845_74845042_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..555176e0271edcc994c0897d3f7d8446015362ec
--- /dev/null
+++ b/tasks/0074_845_74845042_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0074_845_74845042_qa_5"
+description = "What is the total number of samples and features in the preprocessed dataset used for modeling?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0074/845/74845042.ipynb_qa_5"
+kaggle_dataset_name = "uciml/autompg-dataset"
+gold_answer = "398, 8"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__autompg-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/autompg-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "398, 8"
+QUESTION = "What is the total number of samples and features in the preprocessed dataset used for modeling?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0074_918_74918107_qa_4/instruction.md b/tasks/0074_918_74918107_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3a9f15730f8f9077f91cff3259b7bf73c3c86152
--- /dev/null
+++ b/tasks/0074_918_74918107_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the count of missing values in the 'engine_hp' column, and which other column has a similar number of missing entries?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0074_918_74918107_qa_4/task.toml b/tasks/0074_918_74918107_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..aa8f020b9c1390b437483bd44daa6b3f8bf849e0
--- /dev/null
+++ b/tasks/0074_918_74918107_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0074_918_74918107_qa_4"
+description = "What is the count of missing values in the 'engine_hp' column, and which other column has a similar number of missing entries?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0074/918/74918107.ipynb_qa_4"
+kaggle_dataset_name = "CooperUnion/cardataset"
+gold_answer = "69"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "CooperUnion__cardataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "CooperUnion/cardataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "69"
+QUESTION = "What is the count of missing values in the 'engine_hp' column, and which other column has a similar number of missing entries?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0075_061_75061101_qa_2/instruction.md b/tasks/0075_061_75061101_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4e1a9ab8e68d962e0d3255ae77d8a53e4efa6d38
--- /dev/null
+++ b/tasks/0075_061_75061101_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most frequently sold video game genre globally based on the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0075_061_75061101_qa_2/task.toml b/tasks/0075_061_75061101_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..085022e58e0995b0b91bb136e5d1e115c8394329
--- /dev/null
+++ b/tasks/0075_061_75061101_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0075_061_75061101_qa_2"
+description = "What is the most frequently sold video game genre globally based on the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0075/061/75061101.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Action"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Action"
+QUESTION = "What is the most frequently sold video game genre globally based on the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0075_131_75131662_qa_1/instruction.md b/tasks/0075_131_75131662_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..dbc0cc5d08a3d6eee4641e2360b9c1c5becf7966
--- /dev/null
+++ b/tasks/0075_131_75131662_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+- test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature had the highest maximum absolute z-score before outlier removal?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0075_131_75131662_qa_1/task.toml b/tasks/0075_131_75131662_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..03ccad14c72715f23361b6f7af52de4ea3d08859
--- /dev/null
+++ b/tasks/0075_131_75131662_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0075_131_75131662_qa_1"
+description = "Which feature had the highest maximum absolute z-score before outlier removal?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0075/131/75131662.ipynb_qa_1"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "fc"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "fc"
+QUESTION = "Which feature had the highest maximum absolute z-score before outlier removal?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0075_282_75282744_qa_2/instruction.md b/tasks/0075_282_75282744_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..282d84923d91ce6fda487fccebd90f0583de5b20
--- /dev/null
+++ b/tasks/0075_282_75282744_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean alcohol content for wines classified as good quality (1) in the transformed dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0075_282_75282744_qa_2/task.toml b/tasks/0075_282_75282744_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e896fb9662b1cd66985f0179fa96e0cbfd585e9f
--- /dev/null
+++ b/tasks/0075_282_75282744_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0075_282_75282744_qa_2"
+description = "What is the mean alcohol content for wines classified as good quality (1) in the transformed dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0075/282/75282744.ipynb_qa_2"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "11.465913"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "11.465913"
+QUESTION = "What is the mean alcohol content for wines classified as good quality (1) in the transformed dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0075_402_75402843_qa_3/instruction.md b/tasks/0075_402_75402843_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..33515356c5a8aa9e11faf54afbc9ff80da069eec
--- /dev/null
+++ b/tasks/0075_402_75402843_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- ramen-ratings.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which brand appears most frequently in the Top Ten Ramen list across all years?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0075_402_75402843_qa_3/task.toml b/tasks/0075_402_75402843_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..93180906a6bc2fa9f7cf721411f53f58f850fad8
--- /dev/null
+++ b/tasks/0075_402_75402843_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0075_402_75402843_qa_3"
+description = "Which brand appears most frequently in the Top Ten Ramen list across all years?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0075/402/75402843.ipynb_qa_3"
+kaggle_dataset_name = "residentmario/ramen-ratings"
+gold_answer = "Prima Taste"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "residentmario__ramen-ratings"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "residentmario/ramen-ratings"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Prima Taste"
+QUESTION = "Which brand appears most frequently in the Top Ten Ramen list across all years?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0075_402_75402843_qa_5/instruction.md b/tasks/0075_402_75402843_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..56bebf88aebe463dcb54a1cb50943ca5db4af969
--- /dev/null
+++ b/tasks/0075_402_75402843_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which year had the highest number of ramen products listed in the Top Ten?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0075_402_75402843_qa_5/task.toml b/tasks/0075_402_75402843_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9cda56ca1087ce5d9884a7718acb348230dbb6b7
--- /dev/null
+++ b/tasks/0075_402_75402843_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0075_402_75402843_qa_5"
+description = "Which year had the highest number of ramen products listed in the Top Ten?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0075/402/75402843.ipynb_qa_5"
+kaggle_dataset_name = "residentmario/ramen-ratings"
+gold_answer = "2015"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "residentmario__ramen-ratings"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "residentmario/ramen-ratings"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2015"
+QUESTION = "Which year had the highest number of ramen products listed in the Top Ten?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0075_744_75744297_qa_3/instruction.md b/tasks/0075_744_75744297_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6ecd20e5c99e41ecc5490323a8d62909d4702a26
--- /dev/null
+++ b/tasks/0075_744_75744297_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference in test accuracy between the Decision Tree model trained on unscaled data (0.6275) and the same model trained on Robust Scaled data (0.55)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0075_744_75744297_qa_3/task.toml b/tasks/0075_744_75744297_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8c7ffa8f8ae6ed7f796ec5581bdb66cceffbf0c7
--- /dev/null
+++ b/tasks/0075_744_75744297_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0075_744_75744297_qa_3"
+description = "What is the difference in test accuracy between the Decision Tree model trained on unscaled data (0.6275) and the same model trained on Robust Scaled data (0.55)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0075/744/75744297.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "0.0775"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.0775"
+QUESTION = "What is the difference in test accuracy between the Decision Tree model trained on unscaled data (0.6275) and the same model trained on Robust Scaled data (0.55)?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0076_310_76310705_qa_1/instruction.md b/tasks/0076_310_76310705_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f6b9a0355a197c490df57f44eefad2fb0a58de48
--- /dev/null
+++ b/tasks/0076_310_76310705_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the dataset has the highest percentage of missing values after replacing zero values with NaN?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0076_310_76310705_qa_1/task.toml b/tasks/0076_310_76310705_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..99f03f77b7eb4c9c2fc327ed58fb3d46012e6257
--- /dev/null
+++ b/tasks/0076_310_76310705_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0076_310_76310705_qa_1"
+description = "Which feature in the dataset has the highest percentage of missing values after replacing zero values with NaN?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0076/310/76310705.ipynb_qa_1"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Insulin"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Insulin"
+QUESTION = "Which feature in the dataset has the highest percentage of missing values after replacing zero values with NaN?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0076_770_76770209_qa_3/instruction.md b/tasks/0076_770_76770209_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..51992fcf9b193d8bfb216166e4da992eec96b0c6
--- /dev/null
+++ b/tasks/0076_770_76770209_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which internet service type has the lowest churn rate in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0076_770_76770209_qa_3/task.toml b/tasks/0076_770_76770209_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2d230470fae46b61facb26dce07b56139a6c8909
--- /dev/null
+++ b/tasks/0076_770_76770209_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0076_770_76770209_qa_3"
+description = "Which internet service type has the lowest churn rate in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0076/770/76770209.ipynb_qa_3"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "No"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "No"
+QUESTION = "Which internet service type has the lowest churn rate in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0076_770_76770209_qa_4/instruction.md b/tasks/0076_770_76770209_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..761c126727ee3996115af99cbe9ea4ddf786020b
--- /dev/null
+++ b/tasks/0076_770_76770209_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which payment method has the highest churn rate in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0076_770_76770209_qa_4/task.toml b/tasks/0076_770_76770209_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..255d3cbb5e2396c0bba683dc6bc67771ccb147da
--- /dev/null
+++ b/tasks/0076_770_76770209_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0076_770_76770209_qa_4"
+description = "Which payment method has the highest churn rate in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0076/770/76770209.ipynb_qa_4"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "Electronic check"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Electronic check"
+QUESTION = "Which payment method has the highest churn rate in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0077_266_77266642_qa_3/instruction.md b/tasks/0077_266_77266642_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..115a97ed7166cd78853c13e3cc13d4a5871e68c6
--- /dev/null
+++ b/tasks/0077_266_77266642_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which chemical property has the highest feature importance in predicting the simplified wine quality using the Random Forest classifier?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0077_266_77266642_qa_3/task.toml b/tasks/0077_266_77266642_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..44a5089f74b81672d77235610034027b68550102
--- /dev/null
+++ b/tasks/0077_266_77266642_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0077_266_77266642_qa_3"
+description = "Which chemical property has the highest feature importance in predicting the simplified wine quality using the Random Forest classifier?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0077/266/77266642.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "alcohol"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "alcohol"
+QUESTION = "Which chemical property has the highest feature importance in predicting the simplified wine quality using the Random Forest classifier?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0077_845_77845573_qa_5/instruction.md b/tasks/0077_845_77845573_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..73e91c106b9450755e0d31dec7dc45faa1ccb0ec
--- /dev/null
+++ b/tasks/0077_845_77845573_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the standard deviation of the 'chlorides' feature in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0077_845_77845573_qa_5/task.toml b/tasks/0077_845_77845573_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..18f6e8000237bf39ac38f50c8f9c12c2b65e755f
--- /dev/null
+++ b/tasks/0077_845_77845573_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0077_845_77845573_qa_5"
+description = "What is the standard deviation of the 'chlorides' feature in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0077/845/77845573.ipynb_qa_5"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "0.047065"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.047065"
+QUESTION = "What is the standard deviation of the 'chlorides' feature in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0077_889_77889442_qa_1/instruction.md b/tasks/0077_889_77889442_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7431ee9404dd41256719c91478876215f48e6192
--- /dev/null
+++ b/tasks/0077_889_77889442_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Suicides in India 2001-2012.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which Indian state had the highest total number of suicides between 2001 and 2012?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0077_889_77889442_qa_1/task.toml b/tasks/0077_889_77889442_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5a35b199b074b1c4fa7873ff83a3e38f98154fee
--- /dev/null
+++ b/tasks/0077_889_77889442_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0077_889_77889442_qa_1"
+description = "Which Indian state had the highest total number of suicides between 2001 and 2012?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0077/889/77889442.ipynb_qa_1"
+kaggle_dataset_name = "rajanand/suicides-in-india"
+gold_answer = "Maharashtra"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rajanand__suicides-in-india"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rajanand/suicides-in-india"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Maharashtra"
+QUESTION = "Which Indian state had the highest total number of suicides between 2001 and 2012?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0077_902_77902994_qa_1/instruction.md b/tasks/0077_902_77902994_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9e1b27fdc6e2d2b24b7edf64c5eb5a658042e850
--- /dev/null
+++ b/tasks/0077_902_77902994_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the Pearson correlation coefficient between median income and median house value in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0077_902_77902994_qa_1/task.toml b/tasks/0077_902_77902994_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..da157e77911f4331236d219117a3e4cf0e960725
--- /dev/null
+++ b/tasks/0077_902_77902994_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0077_902_77902994_qa_1"
+description = "What is the Pearson correlation coefficient between median income and median house value in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0077/902/77902994.ipynb_qa_1"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "0.688075"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.688075"
+QUESTION = "What is the Pearson correlation coefficient between median income and median house value in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0080_863_80863637_qa_4/instruction.md b/tasks/0080_863_80863637_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..19914f463acf3a91ba4d76f65f598ea6cfb85ce6
--- /dev/null
+++ b/tasks/0080_863_80863637_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After preprocessing, how many unique values are present in the 'EducationField' column?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0080_863_80863637_qa_4/task.toml b/tasks/0080_863_80863637_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d84733acc93bd0aa99ad407794fe3f4f0f824579
--- /dev/null
+++ b/tasks/0080_863_80863637_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0080_863_80863637_qa_4"
+description = "After preprocessing, how many unique values are present in the 'EducationField' column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0080/863/80863637.ipynb_qa_4"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "6"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6"
+QUESTION = "After preprocessing, how many unique values are present in the 'EducationField' column?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0080_863_80863637_qa_5/instruction.md b/tasks/0080_863_80863637_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d1efe8a940f94e00896f0a1f5356598c0becf3be
--- /dev/null
+++ b/tasks/0080_863_80863637_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After creating the 'FracYearsAtCompany' feature, how many missing values are present in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0080_863_80863637_qa_5/task.toml b/tasks/0080_863_80863637_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ca474dcd82c071dc48701a86795924b546937712
--- /dev/null
+++ b/tasks/0080_863_80863637_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0080_863_80863637_qa_5"
+description = "After creating the 'FracYearsAtCompany' feature, how many missing values are present in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0080/863/80863637.ipynb_qa_5"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0"
+QUESTION = "After creating the 'FracYearsAtCompany' feature, how many missing values are present in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0081_173_81173353_qa_2/instruction.md b/tasks/0081_173_81173353_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d0696930c619d8f3168153785e1450ef6701bbb
--- /dev/null
+++ b/tasks/0081_173_81173353_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- KaggleV2-May-2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the maximum value in the original Handcap column before it was binarized to 0/1 in the preprocessing step?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0081_173_81173353_qa_2/task.toml b/tasks/0081_173_81173353_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8d05473044c7bc5b1092fa57cfe9ef239a278729
--- /dev/null
+++ b/tasks/0081_173_81173353_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0081_173_81173353_qa_2"
+description = "What was the maximum value in the original Handcap column before it was binarized to 0/1 in the preprocessing step?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0081/173/81173353.ipynb_qa_2"
+kaggle_dataset_name = "joniarroba/noshowappointments"
+gold_answer = "4"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "joniarroba__noshowappointments"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "joniarroba/noshowappointments"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4"
+QUESTION = "What was the maximum value in the original Handcap column before it was binarized to 0/1 in the preprocessing step?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0081_173_81173353_qa_3/instruction.md b/tasks/0081_173_81173353_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..54d697cb54871c3d8a6eeb16486bb7e4964b9b3c
--- /dev/null
+++ b/tasks/0081_173_81173353_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- KaggleV2-May-2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many unique patient IDs are present in the original dataset before any preprocessing steps?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0081_173_81173353_qa_3/task.toml b/tasks/0081_173_81173353_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..518046cab4a53d908eb14231ec16f7d6e2794362
--- /dev/null
+++ b/tasks/0081_173_81173353_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0081_173_81173353_qa_3"
+description = "How many unique patient IDs are present in the original dataset before any preprocessing steps?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0081/173/81173353.ipynb_qa_3"
+kaggle_dataset_name = "joniarroba/noshowappointments"
+gold_answer = "62299"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "joniarroba__noshowappointments"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "joniarroba/noshowappointments"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "62299"
+QUESTION = "How many unique patient IDs are present in the original dataset before any preprocessing steps?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0081_459_81459159_qa_1/instruction.md b/tasks/0081_459_81459159_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b58ce96eec320f9c6433bab15df4487fe31a1e1d
--- /dev/null
+++ b/tasks/0081_459_81459159_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many missing values were present in the 'total_bedrooms' column before imputation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0081_459_81459159_qa_1/task.toml b/tasks/0081_459_81459159_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..eb3ec23f41a396bc318e51a2d9f12d2472c24f28
--- /dev/null
+++ b/tasks/0081_459_81459159_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0081_459_81459159_qa_1"
+description = "How many missing values were present in the 'total_bedrooms' column before imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0081/459/81459159.ipynb_qa_1"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "207"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "207"
+QUESTION = "How many missing values were present in the 'total_bedrooms' column before imputation?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0081_485_81485574_qa_1/instruction.md b/tasks/0081_485_81485574_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7292b9eacc15cdd964689c9abc96908e73849e02
--- /dev/null
+++ b/tasks/0081_485_81485574_qa_1/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- games.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average number of turns played in chess games categorized by the four rating levels (low, mid, high, pro)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as comma-separated <rating>:<average> pairs, rating label first, with averages as plain numbers.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0081_485_81485574_qa_1/task.toml b/tasks/0081_485_81485574_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9ddb324c3919600b87e25c40ec6e472c65f9c39c
--- /dev/null
+++ b/tasks/0081_485_81485574_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0081_485_81485574_qa_1"
+description = "What is the average number of turns played in chess games categorized by the four rating levels (low, mid, high, pro)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0081/485/81485574.ipynb_qa_1"
+kaggle_dataset_name = "datasnaek/chess"
+gold_answer = "low: 50.0, mid: 58.0, high: 65.0, pro: 70.0"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "datasnaek__chess"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "datasnaek/chess"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "low: 50.0, mid: 58.0, high: 65.0, pro: 70.0"
+QUESTION = "What is the average number of turns played in chess games categorized by the four rating levels (low, mid, high, pro)?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0081_833_81833134_qa_4/instruction.md b/tasks/0081_833_81833134_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..851fb8a297455374bc2382ee2d0c73587a8ace88
--- /dev/null
+++ b/tasks/0081_833_81833134_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between customer tenure and churn status, and what does the direction indicate?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0081_833_81833134_qa_4/task.toml b/tasks/0081_833_81833134_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9f06d68a14391dc90a7ba82b8343f19e6866bad2
--- /dev/null
+++ b/tasks/0081_833_81833134_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0081_833_81833134_qa_4"
+description = "What is the correlation coefficient between customer tenure and churn status, and what does the direction indicate?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0081/833/81833134.ipynb_qa_4"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "-0.35"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-0.35"
+QUESTION = "What is the correlation coefficient between customer tenure and churn status, and what does the direction indicate?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0082_373_82373986_qa_1/instruction.md b/tasks/0082_373_82373986_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5dd940c227aaed57919c3ece01ad5398c6b3461f
--- /dev/null
+++ b/tasks/0082_373_82373986_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- olivetti_faces.npy
+- olivetti_faces_target.npy
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average number of images per unique individual in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0082_373_82373986_qa_1/task.toml b/tasks/0082_373_82373986_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..89c73e87be570e46a1736a49c723f2c0a35aa20f
--- /dev/null
+++ b/tasks/0082_373_82373986_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0082_373_82373986_qa_1"
+description = "What is the average number of images per unique individual in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0082/373/82373986.ipynb_qa_1"
+kaggle_dataset_name = "imrandude/olivetti"
+gold_answer = "10"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "imrandude__olivetti"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "imrandude/olivetti"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "10"
+QUESTION = "What is the average number of images per unique individual in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0082_498_82498397_qa_3/instruction.md b/tasks/0082_498_82498397_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..429c08ad411c13cf2e474651b252f6fc1fbb9938
--- /dev/null
+++ b/tasks/0082_498_82498397_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- bs140513_032310.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which age group (as categorized in the dataset) has the highest fraud rate percentage?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0082_498_82498397_qa_3/task.toml b/tasks/0082_498_82498397_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..01db6e560c4033807a37b68a67ae7d82d49055fc
--- /dev/null
+++ b/tasks/0082_498_82498397_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0082_498_82498397_qa_3"
+description = "Which age group (as categorized in the dataset) has the highest fraud rate percentage?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0082/498/82498397.ipynb_qa_3"
+kaggle_dataset_name = "ealaxi/banksim1"
+gold_answer = "0"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ealaxi__banksim1"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ealaxi/banksim1"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0"
+QUESTION = "Which age group (as categorized in the dataset) has the highest fraud rate percentage?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0082_498_82498397_qa_4/instruction.md b/tasks/0082_498_82498397_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..09ac15c8b54d1d94ec42519372697168407dce7b
--- /dev/null
+++ b/tasks/0082_498_82498397_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- bs140513_032310.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After applying SMOTE oversampling, how many samples are present for each fraud class in the resampled dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0082_498_82498397_qa_4/task.toml b/tasks/0082_498_82498397_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..01714d0b26fdab2325a1b9373da14f26e741e613
--- /dev/null
+++ b/tasks/0082_498_82498397_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0082_498_82498397_qa_4"
+description = "After applying SMOTE oversampling, how many samples are present for each fraud class in the resampled dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0082/498/82498397.ipynb_qa_4"
+kaggle_dataset_name = "ealaxi/banksim1"
+gold_answer = "587443"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ealaxi__banksim1"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ealaxi/banksim1"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "587443"
+QUESTION = "After applying SMOTE oversampling, how many samples are present for each fraud class in the resampled dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0082_619_82619539_qa_1/instruction.md b/tasks/0082_619_82619539_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..94ab533d37c30b79a99e8030ded0e9b81e91ec8c
--- /dev/null
+++ b/tasks/0082_619_82619539_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- catalog.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which month had the highest number of landslide events after parsing the date column into month names?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0082_619_82619539_qa_1/task.toml b/tasks/0082_619_82619539_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b937b6f54774cc50a29afe565420c01a4df89140
--- /dev/null
+++ b/tasks/0082_619_82619539_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0082_619_82619539_qa_1"
+description = "Which month had the highest number of landslide events after parsing the date column into month names?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0082/619/82619539.ipynb_qa_1"
+kaggle_dataset_name = "nasa/landslide-events"
+gold_answer = "July"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "nasa__landslide-events"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "nasa/landslide-events"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "July"
+QUESTION = "Which month had the highest number of landslide events after parsing the date column into month names?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0082_939_82939452_qa_3/instruction.md b/tasks/0082_939_82939452_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c2698d7621775121406554df1a1764710834718a
--- /dev/null
+++ b/tasks/0082_939_82939452_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- bank.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which numerical feature in the dataset has the highest standard deviation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0082_939_82939452_qa_3/task.toml b/tasks/0082_939_82939452_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9d59e0c33ac8a670fc2b13abf655e4940db26bc6
--- /dev/null
+++ b/tasks/0082_939_82939452_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0082_939_82939452_qa_3"
+description = "Which numerical feature in the dataset has the highest standard deviation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0082/939/82939452.ipynb_qa_3"
+kaggle_dataset_name = "janiobachmann/bank-marketing-dataset"
+gold_answer = "balance"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "janiobachmann__bank-marketing-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "balance"
+QUESTION = "Which numerical feature in the dataset has the highest standard deviation?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0084_297_84297732_qa_2/instruction.md b/tasks/0084_297_84297732_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..918062dcd1c766d61f7bde802c4fcd6215cb85e4
--- /dev/null
+++ b/tasks/0084_297_84297732_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median total sulfur dioxide level for wines with quality scores of 3 or 4?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0084_297_84297732_qa_2/task.toml b/tasks/0084_297_84297732_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bc1a078d84f0a36f5c66544a2496d83da3ede37c
--- /dev/null
+++ b/tasks/0084_297_84297732_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0084_297_84297732_qa_2"
+description = "What is the median total sulfur dioxide level for wines with quality scores of 3 or 4?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0084/297/84297732.ipynb_qa_2"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "26"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "26"
+QUESTION = "What is the median total sulfur dioxide level for wines with quality scores of 3 or 4?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0084_297_84297732_qa_4/instruction.md b/tasks/0084_297_84297732_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cb12378232fd2157e34314e0e9cd6aa56b6435b0
--- /dev/null
+++ b/tasks/0084_297_84297732_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the red wine quality dataset has the highest standard deviation across all wines?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0084_297_84297732_qa_4/task.toml b/tasks/0084_297_84297732_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3b0bdf5291d56e7c35bf62dfb55fda95aa050a2c
--- /dev/null
+++ b/tasks/0084_297_84297732_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0084_297_84297732_qa_4"
+description = "Which feature in the red wine quality dataset has the highest standard deviation across all wines?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0084/297/84297732.ipynb_qa_4"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "total sulfur dioxide"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "total sulfur dioxide"
+QUESTION = "Which feature in the red wine quality dataset has the highest standard deviation across all wines?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0084_523_84523209_qa_5/instruction.md b/tasks/0084_523_84523209_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ad976dd9e15f2f71aa20d3db998c74e7c8b5e044
--- /dev/null
+++ b/tasks/0084_523_84523209_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which calendar year had the highest number of video game releases in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0084_523_84523209_qa_5/task.toml b/tasks/0084_523_84523209_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..53f763d454d3fcfea47926192a1e949b33286d25
--- /dev/null
+++ b/tasks/0084_523_84523209_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0084_523_84523209_qa_5"
+description = "Which calendar year had the highest number of video game releases in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0084/523/84523209.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "2008"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2008"
+QUESTION = "Which calendar year had the highest number of video game releases in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0084_981_84981806_qa_1/instruction.md b/tasks/0084_981_84981806_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3946206490ac5e183cdf8caa84e0d9a08963d5ed
--- /dev/null
+++ b/tasks/0084_981_84981806_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the attrition rate (proportion of employees who left) in the original dataset before any modeling?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0084_981_84981806_qa_1/task.toml b/tasks/0084_981_84981806_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7b6dccf8eddba30fa2ae9f495ad75ee9d0ab9854
--- /dev/null
+++ b/tasks/0084_981_84981806_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0084_981_84981806_qa_1"
+description = "What is the attrition rate (proportion of employees who left) in the original dataset before any modeling?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0084/981/84981806.ipynb_qa_1"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "0.1612"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.1612"
+QUESTION = "What is the attrition rate (proportion of employees who left) in the original dataset before any modeling?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0085_151_85151836_qa_1/instruction.md b/tasks/0085_151_85151836_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f90f8256b30d3a54218d7b240c735756e90542da
--- /dev/null
+++ b/tasks/0085_151_85151836_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- index.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Is there a positive correlation between Federal Funds Target Rate and Unemployment Rate according to the analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0085_151_85151836_qa_1/task.toml b/tasks/0085_151_85151836_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0c409885dc3f135914df9b3eecf0204bf8161a11
--- /dev/null
+++ b/tasks/0085_151_85151836_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0085_151_85151836_qa_1"
+description = "Is there a positive correlation between Federal Funds Target Rate and Unemployment Rate according to the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0085/151/85151836.ipynb_qa_1"
+kaggle_dataset_name = "federalreserve/interest-rates"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "federalreserve__interest-rates"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "federalreserve/interest-rates"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Is there a positive correlation between Federal Funds Target Rate and Unemployment Rate according to the analysis?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0085_678_85678308_qa_2/instruction.md b/tasks/0085_678_85678308_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..338fde12fb2c6a108d76b36698c2ca735bf89cc1
--- /dev/null
+++ b/tasks/0085_678_85678308_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which species has the highest median SepalLengthCm value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0085_678_85678308_qa_2/task.toml b/tasks/0085_678_85678308_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8b1137610a03e1b9364953be873eaa649a002191
--- /dev/null
+++ b/tasks/0085_678_85678308_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0085_678_85678308_qa_2"
+description = "Which species has the highest median SepalLengthCm value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0085/678/85678308.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "Iris-virginica"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Iris-virginica"
+QUESTION = "Which species has the highest median SepalLengthCm value?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0085_687_85687102_qa_1/instruction.md b/tasks/0085_687_85687102_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7152981cc077e63e107023f20dc5f515073ee1c4
--- /dev/null
+++ b/tasks/0085_687_85687102_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean cross-validated precision score of the logistic regression model using all features to predict mushroom class?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0085_687_85687102_qa_1/task.toml b/tasks/0085_687_85687102_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e1ae554fa10367046a861048fb78da8d39f2539f
--- /dev/null
+++ b/tasks/0085_687_85687102_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0085_687_85687102_qa_1"
+description = "What is the mean cross-validated precision score of the logistic regression model using all features to predict mushroom class?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0085/687/85687102.ipynb_qa_1"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "0.97"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.97"
+QUESTION = "What is the mean cross-validated precision score of the logistic regression model using all features to predict mushroom class?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0085_750_85750552_qa_2/instruction.md b/tasks/0085_750_85750552_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3af4950c7f2e1bd07a11c242fe5d9d2aee1aba57
--- /dev/null
+++ b/tasks/0085_750_85750552_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average global sales ratio of Nintendo Wii games compared to all other platforms combined?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0085_750_85750552_qa_2/task.toml b/tasks/0085_750_85750552_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f8a8e6ff42c5ed588aacd390696a47f48d2b797d
--- /dev/null
+++ b/tasks/0085_750_85750552_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0085_750_85750552_qa_2"
+description = "What is the average global sales ratio of Nintendo Wii games compared to all other platforms combined?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0085/750/85750552.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "1.34"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.34"
+QUESTION = "What is the average global sales ratio of Nintendo Wii games compared to all other platforms combined?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0085_750_85750552_qa_4/instruction.md b/tasks/0085_750_85750552_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..734696762efa823363872b7f34eff57c181a7c49
--- /dev/null
+++ b/tasks/0085_750_85750552_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median value of North American sales for all video games in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0085_750_85750552_qa_4/task.toml b/tasks/0085_750_85750552_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..be1cc88e27b6f7a5da726cc68102a407e166860e
--- /dev/null
+++ b/tasks/0085_750_85750552_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0085_750_85750552_qa_4"
+description = "What is the median value of North American sales for all video games in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0085/750/85750552.ipynb_qa_4"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "0.08"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.08"
+QUESTION = "What is the median value of North American sales for all video games in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0086_170_86170046_qa_3/instruction.md b/tasks/0086_170_86170046_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..959c0f921728a02090964918535fd3299165cc3b
--- /dev/null
+++ b/tasks/0086_170_86170046_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which criterion (Gini or Entropy) resulted in a higher F1 score for the Random Forest model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0086_170_86170046_qa_3/task.toml b/tasks/0086_170_86170046_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f70d73f5e8055a1776bdc75d23869c2eb1e16163
--- /dev/null
+++ b/tasks/0086_170_86170046_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0086_170_86170046_qa_3"
+description = "Which criterion (Gini or Entropy) resulted in a higher F1 score for the Random Forest model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0086/170/86170046.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "Gini"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Gini"
+QUESTION = "Which criterion (Gini or Entropy) resulted in a higher F1 score for the Random Forest model?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0086_221_86221222_qa_1/instruction.md b/tasks/0086_221_86221222_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cea54cbc5ca8f235d248914ed22efafd0302ab35
--- /dev/null
+++ b/tasks/0086_221_86221222_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- weatherHistory.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation between Apparent Temperature (C) and Temperature (C) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0086_221_86221222_qa_1/task.toml b/tasks/0086_221_86221222_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ecbcece029399158e1b3c0d7891c5d17374ee144
--- /dev/null
+++ b/tasks/0086_221_86221222_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0086_221_86221222_qa_1"
+description = "What is the correlation between Apparent Temperature (C) and Temperature (C) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0086/221/86221222.ipynb_qa_1"
+kaggle_dataset_name = "muthuj7/weather-dataset"
+gold_answer = "0.992637"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "muthuj7__weather-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "muthuj7/weather-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.992637"
+QUESTION = "What is the correlation between Apparent Temperature (C) and Temperature (C) in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0086_817_86817986_qa_4/instruction.md b/tasks/0086_817_86817986_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..71e12ff1ad33a67d35dcc7ee6d9d870c7d370b61
--- /dev/null
+++ b/tasks/0086_817_86817986_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Automobile_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between highway mpg and price?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0086_817_86817986_qa_4/task.toml b/tasks/0086_817_86817986_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ed24980009305c698282f958e3ed2e43a3541b4c
--- /dev/null
+++ b/tasks/0086_817_86817986_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0086_817_86817986_qa_4"
+description = "What is the correlation coefficient between highway mpg and price?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0086/817/86817986.ipynb_qa_4"
+kaggle_dataset_name = "toramky/automobile-dataset"
+gold_answer = "-0.7"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "toramky__automobile-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "toramky/automobile-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-0.7"
+QUESTION = "What is the correlation coefficient between highway mpg and price?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0086_821_86821577_qa_3/instruction.md b/tasks/0086_821_86821577_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1c4feff2920c4cfeaf74fef30c53dcdd1ffbb4a4
--- /dev/null
+++ b/tasks/0086_821_86821577_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- sign_mnist_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many distinct classes are present in the dataset after applying the label mapping?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0086_821_86821577_qa_3/task.toml b/tasks/0086_821_86821577_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6d1875d10d38c065d6f935e8b2f09e5d698f32c5
--- /dev/null
+++ b/tasks/0086_821_86821577_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0086_821_86821577_qa_3"
+description = "How many distinct classes are present in the dataset after applying the label mapping?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0086/821/86821577.ipynb_qa_3"
+kaggle_dataset_name = "datamunge/sign-language-mnist"
+gold_answer = "24"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "datamunge__sign-language-mnist"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "datamunge/sign-language-mnist"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "24"
+QUESTION = "How many distinct classes are present in the dataset after applying the label mapping?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0087_174_87174947_qa_1/instruction.md b/tasks/0087_174_87174947_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8c8d2ff8d6c2b1983fb5d8c39dc12220f526f92b
--- /dev/null
+++ b/tasks/0087_174_87174947_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which wine quality rating has the highest frequency in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0087_174_87174947_qa_1/task.toml b/tasks/0087_174_87174947_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4b8dd712207a44efa9b82764640651ca0758387c
--- /dev/null
+++ b/tasks/0087_174_87174947_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0087_174_87174947_qa_1"
+description = "Which wine quality rating has the highest frequency in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0087/174/87174947.ipynb_qa_1"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "5"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5"
+QUESTION = "Which wine quality rating has the highest frequency in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0087_558_87558511_qa_3/instruction.md b/tasks/0087_558_87558511_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..06bc472d49a439add1f9ead12ab395f7d6e5ce88
--- /dev/null
+++ b/tasks/0087_558_87558511_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which Pokémon has the lowest Total stat value in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0087_558_87558511_qa_3/task.toml b/tasks/0087_558_87558511_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..deba1185623df32aed69da5fa52cec6110fb2243
--- /dev/null
+++ b/tasks/0087_558_87558511_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0087_558_87558511_qa_3"
+description = "Which Pokémon has the lowest Total stat value in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0087/558/87558511.ipynb_qa_3"
+kaggle_dataset_name = "abcsds/pokemon"
+gold_answer = "Sunkern"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abcsds__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abcsds/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Sunkern"
+QUESTION = "Which Pokémon has the lowest Total stat value in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0087_558_87558511_qa_5/instruction.md b/tasks/0087_558_87558511_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0db300b1480144f357131202c22e72f23a2d1317
--- /dev/null
+++ b/tasks/0087_558_87558511_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the name of the Pokémon that is both a Water type and has a Steel type as its second type?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0087_558_87558511_qa_5/task.toml b/tasks/0087_558_87558511_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e930d0bafa8771204d8ef935ee3e7144f78a0a2f
--- /dev/null
+++ b/tasks/0087_558_87558511_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0087_558_87558511_qa_5"
+description = "What is the name of the Pokémon that is both a Water type and has a Steel type as its second type?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0087/558/87558511.ipynb_qa_5"
+kaggle_dataset_name = "abcsds/pokemon"
+gold_answer = "Empoleon"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abcsds__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abcsds/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Empoleon"
+QUESTION = "What is the name of the Pokémon that is both a Water type and has a Steel type as its second type?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0087_676_87676487_qa_3/instruction.md b/tasks/0087_676_87676487_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d88cf41f165dcf0db8adcf800c19f3a51a1abe51
--- /dev/null
+++ b/tasks/0087_676_87676487_qa_3/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.json
+- test.json
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the ID of the recipe with the highest number of ingredients in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0087_676_87676487_qa_3/task.toml b/tasks/0087_676_87676487_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8dc5bc99d2397224d6d3cca12d0f7f44deed3a20
--- /dev/null
+++ b/tasks/0087_676_87676487_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0087_676_87676487_qa_3"
+description = "What is the ID of the recipe with the highest number of ingredients in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0087/676/87676487.ipynb_qa_3"
+kaggle_dataset_name = "kaggle/recipe-ingredients-dataset"
+gold_answer = "3885"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kaggle__recipe-ingredients-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kaggle/recipe-ingredients-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3885"
+QUESTION = "What is the ID of the recipe with the highest number of ingredients in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0087_832_87832429_qa_3/instruction.md b/tasks/0087_832_87832429_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cff02780ad41f5f2388c302fefc175fcc879b262
--- /dev/null
+++ b/tasks/0087_832_87832429_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train_u6lujuX_CVtuZ9i (1).csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many rows were removed from the original dataset after handling missing values?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0087_832_87832429_qa_3/task.toml b/tasks/0087_832_87832429_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d91196f32cb3af91ebdfe27677b2ad2050446487
--- /dev/null
+++ b/tasks/0087_832_87832429_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0087_832_87832429_qa_3"
+description = "How many rows were removed from the original dataset after handling missing values?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0087/832/87832429.ipynb_qa_3"
+kaggle_dataset_name = "ninzaami/loan-predication"
+gold_answer = "134"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ninzaami__loan-predication"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ninzaami/loan-predication"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "134"
+QUESTION = "How many rows were removed from the original dataset after handling missing values?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0087_941_87941186_qa_3/instruction.md b/tasks/0087_941_87941186_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7493ee9b50465c0cf9c6aa27cf89eb3817082b09
--- /dev/null
+++ b/tasks/0087_941_87941186_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After binning the quality scores into categories (bad, good, very good), how many wines were classified as "very good" in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0087_941_87941186_qa_3/task.toml b/tasks/0087_941_87941186_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..39b0a773b85d999abfab0f60e27dce44d7886e1c
--- /dev/null
+++ b/tasks/0087_941_87941186_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0087_941_87941186_qa_3"
+description = "After binning the quality scores into categories (bad, good, very good), how many wines were classified as \"very good\" in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0087/941/87941186.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "217"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "217"
+QUESTION = "After binning the quality scores into categories (bad, good, very good), how many wines were classified as \"very good\" in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0088_305_88305132_qa_4/instruction.md b/tasks/0088_305_88305132_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae7de725ae646adbeba4ac331625b4c493ae8375
--- /dev/null
+++ b/tasks/0088_305_88305132_qa_4/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- tmdb_5000_movies.csv
+- tmdb_5000_credits.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many columns are present in the dataset after selecting the relevant features for recommendation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0088_305_88305132_qa_4/task.toml b/tasks/0088_305_88305132_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1eb170887782043834f2966b7641c8918efb8d9e
--- /dev/null
+++ b/tasks/0088_305_88305132_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0088_305_88305132_qa_4"
+description = "How many columns are present in the dataset after selecting the relevant features for recommendation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0088/305/88305132.ipynb_qa_4"
+kaggle_dataset_name = "tmdb/tmdb-movie-metadata"
+gold_answer = "7"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "tmdb__tmdb-movie-metadata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "7"
+QUESTION = "How many columns are present in the dataset after selecting the relevant features for recommendation?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0088_489_88489992_qa_2/instruction.md b/tasks/0088_489_88489992_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2fa6f2397e82bd1f6627b516f2264fe464f879d0
--- /dev/null
+++ b/tasks/0088_489_88489992_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the range of the pupil-teacher ratio (PTRATIO) in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0088_489_88489992_qa_2/task.toml b/tasks/0088_489_88489992_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5d401284d6c6dd3c57e058d9d3a37dd9c056b8b1
--- /dev/null
+++ b/tasks/0088_489_88489992_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0088_489_88489992_qa_2"
+description = "What is the range of the pupil-teacher ratio (PTRATIO) in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0088/489/88489992.ipynb_qa_2"
+kaggle_dataset_name = "schirmerchad/bostonhoustingmlnd"
+gold_answer = "9.4"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "schirmerchad__bostonhoustingmlnd"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "schirmerchad/bostonhoustingmlnd"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "9.4"
+QUESTION = "What is the range of the pupil-teacher ratio (PTRATIO) in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0090_020_90020807_qa_4/instruction.md b/tasks/0090_020_90020807_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..383fceaf61a5b5410da3b701dba2500f3a1b7aeb
--- /dev/null
+++ b/tasks/0090_020_90020807_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of the original dataset represented diabetic cases before applying SMOTE upsampling?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0090_020_90020807_qa_4/task.toml b/tasks/0090_020_90020807_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c271c271c700aa93d5d53edb1f9cc72a9ad66051
--- /dev/null
+++ b/tasks/0090_020_90020807_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0090_020_90020807_qa_4"
+description = "What percentage of the original dataset represented diabetic cases before applying SMOTE upsampling?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0090/020/90020807.ipynb_qa_4"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "34.89583333333333"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "34.89583333333333"
+QUESTION = "What percentage of the original dataset represented diabetic cases before applying SMOTE upsampling?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0090_648_90648013_qa_4/instruction.md b/tasks/0090_648_90648013_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9624e4d0f84be62c88ae959cf103847c8d3e8c8b
--- /dev/null
+++ b/tasks/0090_648_90648013_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- movie_IMDB.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average IMDB score for Bollywood movies with the genre combination Action|Drama|History|Thriller|War in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0090_648_90648013_qa_4/task.toml b/tasks/0090_648_90648013_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9b625c1d88e4c8b4453d3cf8c1c334cfbf4f3b22
--- /dev/null
+++ b/tasks/0090_648_90648013_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0090_648_90648013_qa_4"
+description = "What is the average IMDB score for Bollywood movies with the genre combination Action|Drama|History|Thriller|War in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0090/648/90648013.ipynb_qa_4"
+kaggle_dataset_name = "ankiijindae/imdb-movie-data"
+gold_answer = "8.5"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ankiijindae__imdb-movie-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ankiijindae/imdb-movie-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "8.5"
+QUESTION = "What is the average IMDB score for Bollywood movies with the genre combination Action|Drama|History|Thriller|War in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0090_720_90720010_qa_2/instruction.md b/tasks/0090_720_90720010_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..eac6e3fdacb8ef0c80d8481005faf31dea2a2600
--- /dev/null
+++ b/tasks/0090_720_90720010_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common wine quality score in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0090_720_90720010_qa_2/task.toml b/tasks/0090_720_90720010_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..12d67905e7638f4bee1b0617552c30d6ebd56fcb
--- /dev/null
+++ b/tasks/0090_720_90720010_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0090_720_90720010_qa_2"
+description = "What is the most common wine quality score in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0090/720/90720010.ipynb_qa_2"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "5"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5"
+QUESTION = "What is the most common wine quality score in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0090_720_90720010_qa_3/instruction.md b/tasks/0090_720_90720010_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4efe370eaf1a53fb81d2fe7ea97daa38ee589119
--- /dev/null
+++ b/tasks/0090_720_90720010_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median alcohol content for all wines in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0090_720_90720010_qa_3/task.toml b/tasks/0090_720_90720010_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ca5809c5187c2214b26affee297d2ea19c7842da
--- /dev/null
+++ b/tasks/0090_720_90720010_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0090_720_90720010_qa_3"
+description = "What is the median alcohol content for all wines in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0090/720/90720010.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "10.2"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "10.2"
+QUESTION = "What is the median alcohol content for all wines in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0091_212_91212287_qa_3/instruction.md b/tasks/0091_212_91212287_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..72d5bde58255f040f7cc61fa069b5895c9700faf
--- /dev/null
+++ b/tasks/0091_212_91212287_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the median value used to impute missing BloodPressure measurements during data cleaning?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0091_212_91212287_qa_3/task.toml b/tasks/0091_212_91212287_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..867f432d2a70573c9dcb865a0cf132b963cd6986
--- /dev/null
+++ b/tasks/0091_212_91212287_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0091_212_91212287_qa_3"
+description = "What was the median value used to impute missing BloodPressure measurements during data cleaning?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0091/212/91212287.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "72"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "72"
+QUESTION = "What was the median value used to impute missing BloodPressure measurements during data cleaning?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0091_690_91690951_qa_3/instruction.md b/tasks/0091_690_91690951_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7e5647a44168cdd928b3622a551c56b7d41c5e36
--- /dev/null
+++ b/tasks/0091_690_91690951_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Does the data visualization in the notebook confirm that smoking status has a statistically significant impact on insurance charges compared to non-smoking status?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0091_690_91690951_qa_3/task.toml b/tasks/0091_690_91690951_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..92a96325317bce9b2989a68636b9d4de32e489e8
--- /dev/null
+++ b/tasks/0091_690_91690951_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0091_690_91690951_qa_3"
+description = "Does the data visualization in the notebook confirm that smoking status has a statistically significant impact on insurance charges compared to non-smoking status?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0091/690/91690951.ipynb_qa_3"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Does the data visualization in the notebook confirm that smoking status has a statistically significant impact on insurance charges compared to non-smoking status?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0091_690_91690951_qa_4/instruction.md b/tasks/0091_690_91690951_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1932223c0a030564be5c1eada993cea7f16290ad
--- /dev/null
+++ b/tasks/0091_690_91690951_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Based on the KDE plot analysis, does the correlation between BMI and insurance charges appear stronger for smokers compared to non-smokers?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0091_690_91690951_qa_4/task.toml b/tasks/0091_690_91690951_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8057eead01e4ae5c2fe459e93e2a17bba67aa017
--- /dev/null
+++ b/tasks/0091_690_91690951_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0091_690_91690951_qa_4"
+description = "Based on the KDE plot analysis, does the correlation between BMI and insurance charges appear stronger for smokers compared to non-smokers?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0091/690/91690951.ipynb_qa_4"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Based on the KDE plot analysis, does the correlation between BMI and insurance charges appear stronger for smokers compared to non-smokers?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0091_853_91853988_qa_2/instruction.md b/tasks/0091_853_91853988_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac2254a0c7fa330f012930b247a7982f46aa4e07
--- /dev/null
+++ b/tasks/0091_853_91853988_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which column was removed from the dataset due to containing all missing values, and how many columns remained in the dataset after this removal?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <column_name>, <value> (comma-separated, column name first, plain number).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0091_853_91853988_qa_2/task.toml b/tasks/0091_853_91853988_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d495246119a25faeb96c0176304389f77b975a27
--- /dev/null
+++ b/tasks/0091_853_91853988_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0091_853_91853988_qa_2"
+description = "Which column was removed from the dataset due to containing all missing values, and how many columns remained in the dataset after this removal?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0091/853/91853988.ipynb_qa_2"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "Unnamed: 32, 32"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Unnamed: 32, 32"
+QUESTION = "Which column was removed from the dataset due to containing all missing values, and how many columns remained in the dataset after this removal?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0092_376_92376137_qa_3/instruction.md b/tasks/0092_376_92376137_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e1b347b07df976471cdcbc01a9830eaf53125ee5
--- /dev/null
+++ b/tasks/0092_376_92376137_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- tweets.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of tweets by Hillary Clinton after removing rows with missing values in the 'handle' column?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0092_376_92376137_qa_3/task.toml b/tasks/0092_376_92376137_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..72c5afa2cd044cd74a902e97b436206e20a166f5
--- /dev/null
+++ b/tasks/0092_376_92376137_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0092_376_92376137_qa_3"
+description = "What is the total number of tweets by Hillary Clinton after removing rows with missing values in the 'handle' column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0092/376/92376137.ipynb_qa_3"
+kaggle_dataset_name = "benhamner/clinton-trump-tweets"
+gold_answer = "3226"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "benhamner__clinton-trump-tweets"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "benhamner/clinton-trump-tweets"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3226"
+QUESTION = "What is the total number of tweets by Hillary Clinton after removing rows with missing values in the 'handle' column?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0092_936_92936463_qa_5/instruction.md b/tasks/0092_936_92936463_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d706612a32a21de53dbed11974809777c47aac67
--- /dev/null
+++ b/tasks/0092_936_92936463_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which variable demonstrated the strongest positive correlation with wine quality according to the correlation analysis in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0092_936_92936463_qa_5/task.toml b/tasks/0092_936_92936463_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d29935984fa12d093d55f32c7d8936aa3d62132c
--- /dev/null
+++ b/tasks/0092_936_92936463_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0092_936_92936463_qa_5"
+description = "Which variable demonstrated the strongest positive correlation with wine quality according to the correlation analysis in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0092/936/92936463.ipynb_qa_5"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "alcohol"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "alcohol"
+QUESTION = "Which variable demonstrated the strongest positive correlation with wine quality according to the correlation analysis in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0092_990_92990642_qa_2/instruction.md b/tasks/0092_990_92990642_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..51d3b7390c76e74e6582afe36e05d9af1d3e2fc8
--- /dev/null
+++ b/tasks/0092_990_92990642_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which three features were identified as most significant in predicting medical costs by the Random Forest model based on feature importance analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the exact feature names.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0092_990_92990642_qa_2/task.toml b/tasks/0092_990_92990642_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d0218a2df65cecf73981026f19ed5a789556ab75
--- /dev/null
+++ b/tasks/0092_990_92990642_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0092_990_92990642_qa_2"
+description = "Which three features were identified as most significant in predicting medical costs by the Random Forest model based on feature importance analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0092/990/92990642.ipynb_qa_2"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "smoker_yes, bmi_category, age"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "smoker_yes, bmi_category, age"
+QUESTION = "Which three features were identified as most significant in predicting medical costs by the Random Forest model based on feature importance analysis?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0093_643_93643564_qa_1/instruction.md b/tasks/0093_643_93643564_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ef58f876972a5b5824c936c08b1da68e118959e9
--- /dev/null
+++ b/tasks/0093_643_93643564_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of employees in the dataset have left the company (attrition)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0093_643_93643564_qa_1/task.toml b/tasks/0093_643_93643564_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..637f1e2992087e87530a95a6629086eeffcab652
--- /dev/null
+++ b/tasks/0093_643_93643564_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0093_643_93643564_qa_1"
+description = "What percentage of employees in the dataset have left the company (attrition)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0093/643/93643564.ipynb_qa_1"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "16.12"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "16.12"
+QUESTION = "What percentage of employees in the dataset have left the company (attrition)?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0093_755_93755212_qa_4/instruction.md b/tasks/0093_755_93755212_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0e9a8793b69a24c5e5f856e5c78bda09d4b90050
--- /dev/null
+++ b/tasks/0093_755_93755212_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest recorded insurance charge in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0093_755_93755212_qa_4/task.toml b/tasks/0093_755_93755212_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7bc20a0d7abce42ac0d5e6d2c425bee2c8f00c61
--- /dev/null
+++ b/tasks/0093_755_93755212_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0093_755_93755212_qa_4"
+description = "What is the highest recorded insurance charge in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0093/755/93755212.ipynb_qa_4"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "63770.428010"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "63770.428010"
+QUESTION = "What is the highest recorded insurance charge in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0094_443_94443300_qa_3/instruction.md b/tasks/0094_443_94443300_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..314f6008820fb0dac10832eb711b3c52d0403c38
--- /dev/null
+++ b/tasks/0094_443_94443300_qa_3/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- test.csv
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of the dataset includes mobile phones with dual_sim enabled?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0094_443_94443300_qa_3/task.toml b/tasks/0094_443_94443300_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..67f1cbaff52c602dfec158c80bdaa70b2df092d8
--- /dev/null
+++ b/tasks/0094_443_94443300_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0094_443_94443300_qa_3"
+description = "What percentage of the dataset includes mobile phones with dual_sim enabled?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0094/443/94443300.ipynb_qa_3"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "50.95"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "50.95"
+QUESTION = "What percentage of the dataset includes mobile phones with dual_sim enabled?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0094_688_94688742_qa_2/instruction.md b/tasks/0094_688_94688742_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2d2f5365505185e231607ae693692ac911a52ebd
--- /dev/null
+++ b/tasks/0094_688_94688742_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most frequent video game genre in the dataset, and how many games belong to that genre?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0094_688_94688742_qa_2/task.toml b/tasks/0094_688_94688742_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7cd2d3d69aaa53456419d2cd4a14379aa06820e9
--- /dev/null
+++ b/tasks/0094_688_94688742_qa_2/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0094_688_94688742_qa_2"
+description = "What is the most frequent video game genre in the dataset, and how many games belong to that genre?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0094/688/94688742.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Action with 3,316 games"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Action with 3,316 games"
+QUESTION = "What is the most frequent video game genre in the dataset, and how many games belong to that genre?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0094_698_94698351_qa_2/instruction.md b/tasks/0094_698_94698351_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..70bdf360f019d4f366bc2c9c4b99a0fecc93d1aa
--- /dev/null
+++ b/tasks/0094_698_94698351_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median North American sales value in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0094_698_94698351_qa_2/task.toml b/tasks/0094_698_94698351_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..33227075a896ad18e2b209168d165e6a89e63fcc
--- /dev/null
+++ b/tasks/0094_698_94698351_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0094_698_94698351_qa_2"
+description = "What is the median North American sales value in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0094/698/94698351.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "0.08"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.08"
+QUESTION = "What is the median North American sales value in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0095_053_95053072_qa_1/instruction.md b/tasks/0095_053_95053072_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..08591d6d2db7441eadfc7e7cd4b72d993a6d22df
--- /dev/null
+++ b/tasks/0095_053_95053072_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between age and medical insurance charges in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0095_053_95053072_qa_1/task.toml b/tasks/0095_053_95053072_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..411835208ff0628c78726717eabac1d5505e5a1c
--- /dev/null
+++ b/tasks/0095_053_95053072_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0095_053_95053072_qa_1"
+description = "What is the correlation coefficient between age and medical insurance charges in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0095/053/95053072.ipynb_qa_1"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "0.299008"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.299008"
+QUESTION = "What is the correlation coefficient between age and medical insurance charges in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0095_339_95339518_qa_5/instruction.md b/tasks/0095_339_95339518_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac502821b31fab39d13c5f75a38baa226750a29b
--- /dev/null
+++ b/tasks/0095_339_95339518_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- adult.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After handling missing values and feature engineering, how many missing values remain in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0095_339_95339518_qa_5/task.toml b/tasks/0095_339_95339518_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8796dfd8650ed5b95a5ec2dba29dfc86e5dce6f2
--- /dev/null
+++ b/tasks/0095_339_95339518_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0095_339_95339518_qa_5"
+description = "After handling missing values and feature engineering, how many missing values remain in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0095/339/95339518.ipynb_qa_5"
+kaggle_dataset_name = "overload10/adult-census-dataset"
+gold_answer = "0"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "overload10__adult-census-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "overload10/adult-census-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0"
+QUESTION = "After handling missing values and feature engineering, how many missing values remain in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0096_192_96192841_qa_2/instruction.md b/tasks/0096_192_96192841_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..860488cf6a9efd4b1192e704f2ea71395bed457e
--- /dev/null
+++ b/tasks/0096_192_96192841_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the dataset has the highest number of outliers detected using the IQR method?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0096_192_96192841_qa_2/task.toml b/tasks/0096_192_96192841_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0fc1035e0ea07c9d02f81c8459b40edf2dc3efc1
--- /dev/null
+++ b/tasks/0096_192_96192841_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0096_192_96192841_qa_2"
+description = "Which feature in the dataset has the highest number of outliers detected using the IQR method?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0096/192/96192841.ipynb_qa_2"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "residual sugar"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "residual sugar"
+QUESTION = "Which feature in the dataset has the highest number of outliers detected using the IQR method?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0096_192_96192841_qa_5/instruction.md b/tasks/0096_192_96192841_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3689bcfaccf29de05c9d6128e3755d26a6fb5bef
--- /dev/null
+++ b/tasks/0096_192_96192841_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the count of unique wine quality samples after deduplication?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0096_192_96192841_qa_5/task.toml b/tasks/0096_192_96192841_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4a577a75536e64b82b22f581c0e983ee12ef22d7
--- /dev/null
+++ b/tasks/0096_192_96192841_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0096_192_96192841_qa_5"
+description = "What is the count of unique wine quality samples after deduplication?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0096/192/96192841.ipynb_qa_5"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "1359"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1359"
+QUESTION = "What is the count of unique wine quality samples after deduplication?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0097_585_97585155_qa_2/instruction.md b/tasks/0097_585_97585155_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..885d5ccd56aa9898368fa1009454404f7afb8470
--- /dev/null
+++ b/tasks/0097_585_97585155_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which numerical feature shows the strongest positive correlation with job satisfaction, and which shows the strongest negative correlation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the exact feature names.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0097_585_97585155_qa_2/task.toml b/tasks/0097_585_97585155_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..96d88e8f04cf10a021e291a1282802d9fb1fff33
--- /dev/null
+++ b/tasks/0097_585_97585155_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0097_585_97585155_qa_2"
+description = "Which numerical feature shows the strongest positive correlation with job satisfaction, and which shows the strongest negative correlation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0097/585/97585155.ipynb_qa_2"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "DailyRate, HourlyRate"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "DailyRate, HourlyRate"
+QUESTION = "Which numerical feature shows the strongest positive correlation with job satisfaction, and which shows the strongest negative correlation?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0097_844_97844965_qa_2/instruction.md b/tasks/0097_844_97844965_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..668af36bc17098cb028c51b8b7b9c30a42ff8ae5
--- /dev/null
+++ b/tasks/0097_844_97844965_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- cereal.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which cereal in Tier 3 has the highest fat percentage, and what is that percentage value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <cereal name>, <percentage> (comma-separated, label first, percentage with two decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0097_844_97844965_qa_2/task.toml b/tasks/0097_844_97844965_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f3d749ce63b8a4adbfb0c672864ccace0a718a97
--- /dev/null
+++ b/tasks/0097_844_97844965_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0097_844_97844965_qa_2"
+description = "Which cereal in Tier 3 has the highest fat percentage, and what is that percentage value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0097/844/97844965.ipynb_qa_2"
+kaggle_dataset_name = "crawford/80-cereals"
+gold_answer = "100% Natural Bran with 17.64%"
+reward_mode_initial = "flexible"
+package_tier = 0
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "crawford__80-cereals"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crawford/80-cereals"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "100% Natural Bran with 17.64%"
+QUESTION = "Which cereal in Tier 3 has the highest fat percentage, and what is that percentage value? Tier refers to the shelf column. Fat percentage = fat_grams / (weight_oz * 28.35) * 100, rounded to 2 decimal places."
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0098_017_98017526_qa_4/instruction.md b/tasks/0098_017_98017526_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..da508f4d41ecf34e0c3c4dbd90eb230a226788f5
--- /dev/null
+++ b/tasks/0098_017_98017526_qa_4/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which video game has the highest recorded global sales in the dataset, and what is its sales value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <game name>, <sales value> (comma-separated, name first, keep decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0098_017_98017526_qa_4/task.toml b/tasks/0098_017_98017526_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..000da1c1bd256c99ade5dc60aa58ce57cdf84817
--- /dev/null
+++ b/tasks/0098_017_98017526_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0098_017_98017526_qa_4"
+description = "Which video game has the highest recorded global sales in the dataset, and what is its sales value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0098/017/98017526.ipynb_qa_4"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Wii Sports, 82.74"
+reward_mode_initial = "list"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Wii Sports, 82.74"
+QUESTION = "Which video game has the highest recorded global sales in the dataset, and what is its sales value?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0098_017_98017526_qa_5/instruction.md b/tasks/0098_017_98017526_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..78e95f2174b9c582965c69f52fa6cbeeb9b2d885
--- /dev/null
+++ b/tasks/0098_017_98017526_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many entries in the dataset have missing values in the Year column?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0098_017_98017526_qa_5/task.toml b/tasks/0098_017_98017526_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d3d1d57cbfb94bd9bdda85c3253927f8498d255e
--- /dev/null
+++ b/tasks/0098_017_98017526_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0098_017_98017526_qa_5"
+description = "How many entries in the dataset have missing values in the Year column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0098/017/98017526.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "271"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "271"
+QUESTION = "How many entries in the dataset have missing values in the Year column?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0098_341_98341485_qa_2/instruction.md b/tasks/0098_341_98341485_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..959d124ebebafc7c5849630e79aa6da12ec40d8d
--- /dev/null
+++ b/tasks/0098_341_98341485_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which SVM kernel achieved the highest precision for the 'Iris-virginica' class in the initial model evaluations?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0098_341_98341485_qa_2/task.toml b/tasks/0098_341_98341485_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..78ac1d1073d0bfa3a7906956e2a663e1b1118d14
--- /dev/null
+++ b/tasks/0098_341_98341485_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0098_341_98341485_qa_2"
+description = "Which SVM kernel achieved the highest precision for the 'Iris-virginica' class in the initial model evaluations?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0098/341/98341485.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "Linear"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Linear"
+QUESTION = "Which SVM kernel achieved the highest precision for the 'Iris-virginica' class in the initial model evaluations?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0098_595_98595052_qa_2/instruction.md b/tasks/0098_595_98595052_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9207630e6e610abf7e5089fed9741d6af650285b
--- /dev/null
+++ b/tasks/0098_595_98595052_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which categorical feature shows the strongest visual correlation with RAM capacity based on scatter plot analysis in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0098_595_98595052_qa_2/task.toml b/tasks/0098_595_98595052_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..701fabf10e7a1aee15d80361ed272779fb8e4b74
--- /dev/null
+++ b/tasks/0098_595_98595052_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0098_595_98595052_qa_2"
+description = "Which categorical feature shows the strongest visual correlation with RAM capacity based on scatter plot analysis in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0098/595/98595052.ipynb_qa_2"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "price_range"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "price_range"
+QUESTION = "Which categorical feature shows the strongest visual correlation with RAM capacity based on scatter plot analysis in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0098_690_98690564_qa_1/instruction.md b/tasks/0098_690_98690564_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7a17a8e9fb2e8302f3021d162163cfad9d045e3b
--- /dev/null
+++ b/tasks/0098_690_98690564_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many outliers are present in the 'smoker' column based on the interquartile range (IQR) method?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0098_690_98690564_qa_1/task.toml b/tasks/0098_690_98690564_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..843e11dd38b1cdbfe8fbab1fd516a9876f640808
--- /dev/null
+++ b/tasks/0098_690_98690564_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0098_690_98690564_qa_1"
+description = "How many outliers are present in the 'smoker' column based on the interquartile range (IQR) method?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0098/690/98690564.ipynb_qa_1"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "274"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "274"
+QUESTION = "How many outliers are present in the 'smoker' column based on the interquartile range (IQR) method?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0098_812_98812520_qa_1/instruction.md b/tasks/0098_812_98812520_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..00a9f7e3f933e3d05916d534ae2be79184d34798
--- /dev/null
+++ b/tasks/0098_812_98812520_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest positive correlation with the price_range in the mobile price dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0098_812_98812520_qa_1/task.toml b/tasks/0098_812_98812520_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9943ef580265cdddd31930a20a3a6c09db2ed596
--- /dev/null
+++ b/tasks/0098_812_98812520_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0098_812_98812520_qa_1"
+description = "Which feature has the highest positive correlation with the price_range in the mobile price dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0098/812/98812520.ipynb_qa_1"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "ram"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "ram"
+QUESTION = "Which feature has the highest positive correlation with the price_range in the mobile price dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0100_390_100390572_qa_1/instruction.md b/tasks/0100_390_100390572_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea3175f3bb58b20bf46efbf76a765edccafefaac
--- /dev/null
+++ b/tasks/0100_390_100390572_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which Pokémon type has the highest average total stats based on the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0100_390_100390572_qa_1/task.toml b/tasks/0100_390_100390572_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f2dd8b4220d9930cd3e8b4e096442baa14dac5b8
--- /dev/null
+++ b/tasks/0100_390_100390572_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0100_390_100390572_qa_1"
+description = "Which Pokémon type has the highest average total stats based on the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0100/390/100390572.ipynb_qa_1"
+kaggle_dataset_name = "abcsds/pokemon"
+gold_answer = "Dragon"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abcsds__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abcsds/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Dragon"
+QUESTION = "Which Pokémon type has the highest average total stats based on the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0101_292_101292104_qa_1/instruction.md b/tasks/0101_292_101292104_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1ab6885fa4aa8b93ea42205f63029a5726427c1a
--- /dev/null
+++ b/tasks/0101_292_101292104_qa_1/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which ocean proximity category has the highest frequency in the dataset, and what is its count?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <category>, <count> (comma-separated, label first, keep the count as a plain number).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0101_292_101292104_qa_1/task.toml b/tasks/0101_292_101292104_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..609def130b0774fad92538d8cd841c09de18be4c
--- /dev/null
+++ b/tasks/0101_292_101292104_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0101_292_101292104_qa_1"
+description = "Which ocean proximity category has the highest frequency in the dataset, and what is its count?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0101/292/101292104.ipynb_qa_1"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "<1H OCEAN, 9136"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "<1H OCEAN, 9136"
+QUESTION = "Which ocean proximity category has the highest frequency in the dataset, and what is its count?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0101_593_101593150_qa_3/instruction.md b/tasks/0101_593_101593150_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0a5561d743447bfd1489c2587c8fd7d892c02bf
--- /dev/null
+++ b/tasks/0101_593_101593150_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- flavors_of_cacao.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean cocoa percentage for the 'Amazon mix' bean type?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0101_593_101593150_qa_3/task.toml b/tasks/0101_593_101593150_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1652c99370b6d204ce97d5fad18c098ae7c0976e
--- /dev/null
+++ b/tasks/0101_593_101593150_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0101_593_101593150_qa_3"
+description = "What is the mean cocoa percentage for the 'Amazon mix' bean type?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0101/593/101593150.ipynb_qa_3"
+kaggle_dataset_name = "rtatman/chocolate-bar-ratings"
+gold_answer = "74"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rtatman__chocolate-bar-ratings"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rtatman/chocolate-bar-ratings"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "74"
+QUESTION = "What is the mean cocoa percentage for the 'Amazon mix' bean type?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0102_526_102526690_qa_2/instruction.md b/tasks/0102_526_102526690_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..590180fd806bb47686de81ad3c016dd53a098e7d
--- /dev/null
+++ b/tasks/0102_526_102526690_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- wineQualityReds.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the interquartile range (IQR) of the 'quality' scores in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0102_526_102526690_qa_2/task.toml b/tasks/0102_526_102526690_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ce6a013edae80bc698f01312cbe4c25a2d696c0b
--- /dev/null
+++ b/tasks/0102_526_102526690_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0102_526_102526690_qa_2"
+description = "What is the interquartile range (IQR) of the 'quality' scores in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0102/526/102526690.ipynb_qa_2"
+kaggle_dataset_name = "piyushgoyal443/red-wine-dataset"
+gold_answer = "1.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "piyushgoyal443__red-wine-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "piyushgoyal443/red-wine-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.0"
+QUESTION = "What is the interquartile range (IQR) of the 'quality' scores in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0103_407_103407932_qa_1/instruction.md b/tasks/0103_407_103407932_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..19f04f2bd90c9592d2b17c0a351467dd9aa610aa
--- /dev/null
+++ b/tasks/0103_407_103407932_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- AirPassengers.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the p-value from the Augmented Dickey-Fuller test on the original non-stationary time series data?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0103_407_103407932_qa_1/task.toml b/tasks/0103_407_103407932_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..75af1d957d036a671c45cbf12feea2201b663b98
--- /dev/null
+++ b/tasks/0103_407_103407932_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0103_407_103407932_qa_1"
+description = "What is the p-value from the Augmented Dickey-Fuller test on the original non-stationary time series data?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0103/407/103407932.ipynb_qa_1"
+kaggle_dataset_name = "rakannimer/air-passengers"
+gold_answer = "0.991880"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rakannimer__air-passengers"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rakannimer/air-passengers"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.991880"
+QUESTION = "What is the p-value from the Augmented Dickey-Fuller test on the original non-stationary time series data?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0103_696_103696372_qa_4/instruction.md b/tasks/0103_696_103696372_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..251a30e5af4705e22137f2de8bc39db007b965de
--- /dev/null
+++ b/tasks/0103_696_103696372_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between age and BMI in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0103_696_103696372_qa_4/task.toml b/tasks/0103_696_103696372_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..572938c886a4c750853c5a76ffa03d0094d3c73c
--- /dev/null
+++ b/tasks/0103_696_103696372_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0103_696_103696372_qa_4"
+description = "What is the correlation coefficient between age and BMI in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0103/696/103696372.ipynb_qa_4"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "0.109"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.109"
+QUESTION = "What is the correlation coefficient between age and BMI in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0103_923_103923129_qa_1/instruction.md b/tasks/0103_923_103923129_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..97a4527735a0b9cb50287a467a1910513035dfbf
--- /dev/null
+++ b/tasks/0103_923_103923129_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature is identified as the most important by the RandomForestClassifier based on feature importance analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0103_923_103923129_qa_1/task.toml b/tasks/0103_923_103923129_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d572a7038e8d3f62ed7967155b0f0a3fb4b60199
--- /dev/null
+++ b/tasks/0103_923_103923129_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0103_923_103923129_qa_1"
+description = "Which feature is identified as the most important by the RandomForestClassifier based on feature importance analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0103/923/103923129.ipynb_qa_1"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "odor"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "odor"
+QUESTION = "Which feature is identified as the most important by the RandomForestClassifier based on feature importance analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0104_905_104905979_qa_1/instruction.md b/tasks/0104_905_104905979_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cfb00699aaaff8edd3d93b5070802cfe064ce477
--- /dev/null
+++ b/tasks/0104_905_104905979_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the accuracy of the customer churn prediction model on the test dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0104_905_104905979_qa_1/task.toml b/tasks/0104_905_104905979_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2429da79144160c0d3a7cc2605e0c3ec74ecce36
--- /dev/null
+++ b/tasks/0104_905_104905979_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0104_905_104905979_qa_1"
+description = "What is the accuracy of the customer churn prediction model on the test dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0104/905/104905979.ipynb_qa_1"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "78.54"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "78.54"
+QUESTION = "What is the accuracy of the customer churn prediction model on the test dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0104_955_104955589_qa_5/instruction.md b/tasks/0104_955_104955589_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3642d4299b36db18c90d84bf940e7f1262f1daec
--- /dev/null
+++ b/tasks/0104_955_104955589_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between age and BMI variables in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0104_955_104955589_qa_5/task.toml b/tasks/0104_955_104955589_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d6eab3a01ee8d00386b46654d2c94e8818fbdde0
--- /dev/null
+++ b/tasks/0104_955_104955589_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0104_955_104955589_qa_5"
+description = "What is the correlation coefficient between age and BMI variables in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0104/955/104955589.ipynb_qa_5"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "0.08"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.08"
+QUESTION = "What is the correlation coefficient between age and BMI variables in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0105_059_105059592_qa_3/instruction.md b/tasks/0105_059_105059592_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5ccc83861ae3dd9cadf23138f296d8ed37a294a7
--- /dev/null
+++ b/tasks/0105_059_105059592_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which contract type has the lowest churn rate according to the analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0105_059_105059592_qa_3/task.toml b/tasks/0105_059_105059592_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..de9eb4170b1b3339af00e50bed2e70137942f450
--- /dev/null
+++ b/tasks/0105_059_105059592_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0105_059_105059592_qa_3"
+description = "Which contract type has the lowest churn rate according to the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0105/059/105059592.ipynb_qa_3"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "Two year"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Two year"
+QUESTION = "Which contract type has the lowest churn rate according to the analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0106_414_106414508_qa_1/instruction.md b/tasks/0106_414_106414508_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e02c678ece6ef9fa8a5ea2a932eb92d0d8dd03ee
--- /dev/null
+++ b/tasks/0106_414_106414508_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- car_evaluation.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most frequent car evaluation decision category in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0106_414_106414508_qa_1/task.toml b/tasks/0106_414_106414508_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a9d7ee0abbd5af2a582fabd1ba22185bab82d371
--- /dev/null
+++ b/tasks/0106_414_106414508_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0106_414_106414508_qa_1"
+description = "What is the most frequent car evaluation decision category in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0106/414/106414508.ipynb_qa_1"
+kaggle_dataset_name = "elikplim/car-evaluation-data-set"
+gold_answer = "unacc"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "elikplim__car-evaluation-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "elikplim/car-evaluation-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "unacc"
+QUESTION = "What is the most frequent car evaluation decision category in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0106_481_106481442_qa_3/instruction.md b/tasks/0106_481_106481442_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ff4fbafef6161f71f1692ad1a676626360a397cf
--- /dev/null
+++ b/tasks/0106_481_106481442_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After applying the Gaussian rule Winsorization method, what is the upper boundary value for the alcohol feature?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0106_481_106481442_qa_3/task.toml b/tasks/0106_481_106481442_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..aba06d718d1aeef57183ee45c77b79bd1c687999
--- /dev/null
+++ b/tasks/0106_481_106481442_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0106_481_106481442_qa_3"
+description = "After applying the Gaussian rule Winsorization method, what is the upper boundary value for the alcohol feature?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0106/481/106481442.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "13.597477858782154"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "13.597477858782154"
+QUESTION = "After applying the Gaussian rule Winsorization method, what is the upper boundary value for the alcohol feature?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0106_490_106490644_qa_3/instruction.md b/tasks/0106_490_106490644_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b56ffac459f6ae4ff41ddea8239b6636233be15e
--- /dev/null
+++ b/tasks/0106_490_106490644_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- UCI_Credit_Card.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which marital status category has the highest number of defaulters in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0106_490_106490644_qa_3/task.toml b/tasks/0106_490_106490644_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..475a081216110d359ef1756f13b3513425277193
--- /dev/null
+++ b/tasks/0106_490_106490644_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0106_490_106490644_qa_3"
+description = "Which marital status category has the highest number of defaulters in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0106/490/106490644.ipynb_qa_3"
+kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset"
+gold_answer = "Single"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__default-of-credit-card-clients-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Single"
+QUESTION = "Which marital status category has the highest number of defaulters in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0106_933_106933480_qa_2/instruction.md b/tasks/0106_933_106933480_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4b65a03e14a31d9d7307922b8d1bff2f2d2fcc19
--- /dev/null
+++ b/tasks/0106_933_106933480_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest Pearson correlation between any feature and the original 'quality' label?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0106_933_106933480_qa_2/task.toml b/tasks/0106_933_106933480_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..79c511a17764de07b94d5c279ea25b37b844c2c3
--- /dev/null
+++ b/tasks/0106_933_106933480_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0106_933_106933480_qa_2"
+description = "What is the highest Pearson correlation between any feature and the original 'quality' label?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0106/933/106933480.ipynb_qa_2"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "0.476166"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.476166"
+QUESTION = "What is the highest Pearson correlation between any feature and the original 'quality' label?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0107_427_107427822_qa_5/instruction.md b/tasks/0107_427_107427822_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0eca92f964bf2b0cdbe61215fc3c9176b4f63ae
--- /dev/null
+++ b/tasks/0107_427_107427822_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference in churn rates between senior citizens (SeniorCitizen=1) and non-senior customers (SeniorCitizen=0)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0107_427_107427822_qa_5/task.toml b/tasks/0107_427_107427822_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e1dcbe9c57f9657d5672b24a40e3687c84cf1195
--- /dev/null
+++ b/tasks/0107_427_107427822_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0107_427_107427822_qa_5"
+description = "What is the difference in churn rates between senior citizens (SeniorCitizen=1) and non-senior customers (SeniorCitizen=0)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0107/427/107427822.ipynb_qa_5"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "18.1"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "18.1"
+QUESTION = "What is the difference in churn rates between senior citizens (SeniorCitizen=1) and non-senior customers (SeniorCitizen=0)?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0107_451_107451857_qa_4/instruction.md b/tasks/0107_451_107451857_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8fb407a57a87a98b98cd582d713f02ab3278beb3
--- /dev/null
+++ b/tasks/0107_451_107451857_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the Pearson correlation coefficient between age and medical charges in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0107_451_107451857_qa_4/task.toml b/tasks/0107_451_107451857_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e856834cdd6c5280b5ef808e0cf1363470af62c2
--- /dev/null
+++ b/tasks/0107_451_107451857_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0107_451_107451857_qa_4"
+description = "What is the Pearson correlation coefficient between age and medical charges in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0107/451/107451857.ipynb_qa_4"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "0.299008"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.299008"
+QUESTION = "What is the Pearson correlation coefficient between age and medical charges in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0108_184_108184818_qa_2/instruction.md b/tasks/0108_184_108184818_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9e3c13d7b694f0e3bbf6541a29b162c1b3d61a01
--- /dev/null
+++ b/tasks/0108_184_108184818_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mushrooms.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common odor type among poisonous mushrooms according to the dataset analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_184_108184818_qa_2/task.toml b/tasks/0108_184_108184818_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5f98c445b5141411dd2ab5623ac9252c40a400df
--- /dev/null
+++ b/tasks/0108_184_108184818_qa_2/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0108_184_108184818_qa_2"
+description = "What is the most common odor type among poisonous mushrooms according to the dataset analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/184/108184818.ipynb_qa_2"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "pungent"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "foul"
+QUESTION = "What is the most common odor type among poisonous mushrooms according to the dataset analysis?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0108_197_108197253_qa_1/instruction.md b/tasks/0108_197_108197253_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..173fc92d41aa93f0173cddfac95f947a924bc903
--- /dev/null
+++ b/tasks/0108_197_108197253_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many features were removed from the dataset due to high correlation (>0.95) between variables?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_197_108197253_qa_1/task.toml b/tasks/0108_197_108197253_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..397590fd38c869b4cd8af2315e1b3bbbca9ac6e7
--- /dev/null
+++ b/tasks/0108_197_108197253_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0108_197_108197253_qa_1"
+description = "How many features were removed from the dataset due to high correlation (>0.95) between variables?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/197/108197253.ipynb_qa_1"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "7"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "7"
+QUESTION = "How many features were removed from the dataset due to high correlation (>0.95) between variables?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0108_225_108225204_qa_2/instruction.md b/tasks/0108_225_108225204_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fb0fa8d419eb7748267143ae344b626eed82d908
--- /dev/null
+++ b/tasks/0108_225_108225204_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many features are used for clustering in the KMeans model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_225_108225204_qa_2/task.toml b/tasks/0108_225_108225204_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..966bcacb195d0e749fb41de40ab3efa39c3a10f3
--- /dev/null
+++ b/tasks/0108_225_108225204_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0108_225_108225204_qa_2"
+description = "How many features are used for clustering in the KMeans model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/225/108225204.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "4"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4"
+QUESTION = "How many features are used for clustering in the KMeans model?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0108_363_108363990_qa_2/instruction.md b/tasks/0108_363_108363990_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5e35568d12db18ac22a81ece5a418b2b968c290
--- /dev/null
+++ b/tasks/0108_363_108363990_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which categorical feature in the dataset has the highest proportion of 'yes' responses?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_363_108363990_qa_2/task.toml b/tasks/0108_363_108363990_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f7edf71887ae764ec084fa25f264af7bea05ba70
--- /dev/null
+++ b/tasks/0108_363_108363990_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0108_363_108363990_qa_2"
+description = "Which categorical feature in the dataset has the highest proportion of 'yes' responses?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/363/108363990.ipynb_qa_2"
+kaggle_dataset_name = "ananthreddy/housing"
+gold_answer = "driveway"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ananthreddy__housing"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ananthreddy/housing"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "driveway"
+QUESTION = "Which categorical feature in the dataset has the highest proportion of 'yes' responses?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0108_379_108379534_qa_2/instruction.md b/tasks/0108_379_108379534_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e88c0858b2dc104cb1b0d9e7e57f2ac2c8492741
--- /dev/null
+++ b/tasks/0108_379_108379534_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of legendary Pokémon have no specific gender assigned in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_379_108379534_qa_2/task.toml b/tasks/0108_379_108379534_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..30ee4f2cbbbe391e5bb60530fa3cd7fea7a5b0f1
--- /dev/null
+++ b/tasks/0108_379_108379534_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0108_379_108379534_qa_2"
+description = "What percentage of legendary Pokémon have no specific gender assigned in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/379/108379534.ipynb_qa_2"
+kaggle_dataset_name = "rounakbanik/pokemon"
+gold_answer = "90"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rounakbanik__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rounakbanik/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "90"
+QUESTION = "What percentage of legendary Pokémon have no specific gender assigned in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0108_423_108423455_qa_3/instruction.md b/tasks/0108_423_108423455_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cda7987f7a803f1d1ad0e600266c344b537ed369
--- /dev/null
+++ b/tasks/0108_423_108423455_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum BMI value recorded in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_423_108423455_qa_3/task.toml b/tasks/0108_423_108423455_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9249922465c11774a0faa8c606ec717887687765
--- /dev/null
+++ b/tasks/0108_423_108423455_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0108_423_108423455_qa_3"
+description = "What is the maximum BMI value recorded in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/423/108423455.ipynb_qa_3"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "53.13"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "53.13"
+QUESTION = "What is the maximum BMI value recorded in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0108_423_108423455_qa_5/instruction.md b/tasks/0108_423_108423455_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d202defde3f02d495d324b59c26a3729125863c2
--- /dev/null
+++ b/tasks/0108_423_108423455_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the standard deviation of BMI values in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_423_108423455_qa_5/task.toml b/tasks/0108_423_108423455_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6aa90b2b21276897c949e076599d22ce35b9682f
--- /dev/null
+++ b/tasks/0108_423_108423455_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0108_423_108423455_qa_5"
+description = "What is the standard deviation of BMI values in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/423/108423455.ipynb_qa_5"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "6.098"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6.098"
+QUESTION = "What is the standard deviation of BMI values in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0108_588_108588873_qa_1/instruction.md b/tasks/0108_588_108588873_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4e04eb1ce0703a488cd940bb18fb7f299c33a5a3
--- /dev/null
+++ b/tasks/0108_588_108588873_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which physicochemical variable demonstrates the strongest positive linear relationship with wine quality based on Pearson correlation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_588_108588873_qa_1/task.toml b/tasks/0108_588_108588873_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..66b89d383f01c41e2f44dd4f249ee5412d188c20
--- /dev/null
+++ b/tasks/0108_588_108588873_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0108_588_108588873_qa_1"
+description = "Which physicochemical variable demonstrates the strongest positive linear relationship with wine quality based on Pearson correlation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/588/108588873.ipynb_qa_1"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "alcohol"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "alcohol"
+QUESTION = "Which physicochemical variable demonstrates the strongest positive linear relationship with wine quality based on Pearson correlation?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0108_641_108641458_qa_3/instruction.md b/tasks/0108_641_108641458_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c57905fe0fa1e3bbab60136befb060a1beff5a16
--- /dev/null
+++ b/tasks/0108_641_108641458_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the ratio of the average global sales for the Nintendo Wii compared to all other platforms combined?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0108_641_108641458_qa_3/task.toml b/tasks/0108_641_108641458_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..58f39eef3dbc411cb3f2a0f2b3ee54ee5c88d8b8
--- /dev/null
+++ b/tasks/0108_641_108641458_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0108_641_108641458_qa_3"
+description = "What is the ratio of the average global sales for the Nintendo Wii compared to all other platforms combined?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0108/641/108641458.ipynb_qa_3"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "1.336"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.336"
+QUESTION = "What is the ratio of the average global sales for the Nintendo Wii compared to all other platforms combined?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0109_165_109165906_qa_3/instruction.md b/tasks/0109_165_109165906_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8afdf9248f92f49d801e995990170bb8c22b0a5d
--- /dev/null
+++ b/tasks/0109_165_109165906_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many standard deviations above the mean North American sales is the top-selling game's performance in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0109_165_109165906_qa_3/task.toml b/tasks/0109_165_109165906_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..863bd7d4723f4923501afcd583dd95d0db7dbd53
--- /dev/null
+++ b/tasks/0109_165_109165906_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0109_165_109165906_qa_3"
+description = "How many standard deviations above the mean North American sales is the top-selling game's performance in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0109/165/109165906.ipynb_qa_3"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "50.48"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "50.48"
+QUESTION = "How many standard deviations above the mean North American sales is the top-selling game's performance in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0109_958_109958191_qa_4/instruction.md b/tasks/0109_958_109958191_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f9d0a9400ef6d58c5d5eda362ea6a30b4396a953
--- /dev/null
+++ b/tasks/0109_958_109958191_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- haberman.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the ratio of the interquartile range (IQR) of axillary lymph nodes for survivors versus non-survivors?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0109_958_109958191_qa_4/task.toml b/tasks/0109_958_109958191_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..398646713e516bdf7f41841513699f8efcfdbceb
--- /dev/null
+++ b/tasks/0109_958_109958191_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0109_958_109958191_qa_4"
+description = "What is the ratio of the interquartile range (IQR) of axillary lymph nodes for survivors versus non-survivors?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0109/958/109958191.ipynb_qa_4"
+kaggle_dataset_name = "gilsousa/habermans-survival-data-set"
+gold_answer = "0.3"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gilsousa__habermans-survival-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.3"
+QUESTION = "What is the ratio of the interquartile range (IQR) of axillary lymph nodes for survivors versus non-survivors?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_336_110336041_qa_2/instruction.md b/tasks/0110_336_110336041_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9478feb76c632ee239713e8202492cade3587ed6
--- /dev/null
+++ b/tasks/0110_336_110336041_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many missing values were present in the 'Unnamed: 32' column before it was dropped from the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_336_110336041_qa_2/task.toml b/tasks/0110_336_110336041_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..926e9196acc572171b37f19ec48fe6f7a56375cf
--- /dev/null
+++ b/tasks/0110_336_110336041_qa_2/task.toml
@@ -0,0 +1,58 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0110_336_110336041_qa_2"
+description = "How many missing values were present in the 'Unnamed: 32' column before it was dropped from the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/336/110336041.ipynb_qa_2"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "569"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "569"
+QUESTION = "How many missing values were present in the 'Unnamed: 32' column before it was dropped from the dataset?"
+REWARD_MODE = "numeric"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0110_384_110384053_qa_4/instruction.md b/tasks/0110_384_110384053_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..58794ad85c7cb77cb8b7470047b2197d3fb4de6d
--- /dev/null
+++ b/tasks/0110_384_110384053_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of unique browsers present in the original dataset before standardization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_384_110384053_qa_4/task.toml b/tasks/0110_384_110384053_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a11376038118f5242539ea0e10f440fe483a81ce
--- /dev/null
+++ b/tasks/0110_384_110384053_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0110_384_110384053_qa_4"
+description = "What is the total number of unique browsers present in the original dataset before standardization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/384/110384053.ipynb_qa_4"
+kaggle_dataset_name = "anu0012/hotel-review"
+gold_answer = "11"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "anu0012__hotel-review"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "anu0012/hotel-review"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "11"
+QUESTION = "What is the total number of unique browsers present in the original dataset before standardization?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_391_110391161_qa_2/instruction.md b/tasks/0110_391_110391161_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b58ce96eec320f9c6433bab15df4487fe31a1e1d
--- /dev/null
+++ b/tasks/0110_391_110391161_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many missing values were present in the 'total_bedrooms' column before imputation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_391_110391161_qa_2/task.toml b/tasks/0110_391_110391161_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8ce4dad8789e101ca770def194c81f87baec8452
--- /dev/null
+++ b/tasks/0110_391_110391161_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0110_391_110391161_qa_2"
+description = "How many missing values were present in the 'total_bedrooms' column before imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/391/110391161.ipynb_qa_2"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "207"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "207"
+QUESTION = "How many missing values were present in the 'total_bedrooms' column before imputation?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_432_110432344_qa_4/instruction.md b/tasks/0110_432_110432344_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..99ff625fe1b283acd64666b5837a5f2cc1ad0553
--- /dev/null
+++ b/tasks/0110_432_110432344_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- MER_T12_06.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between CO₂ emissions from coal and natural gas over the time period shown in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_432_110432344_qa_4/task.toml b/tasks/0110_432_110432344_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8f9350e97b0b02fb750194ce5d6a73ed2c6a2cb3
--- /dev/null
+++ b/tasks/0110_432_110432344_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0110_432_110432344_qa_4"
+description = "What is the correlation coefficient between CO₂ emissions from coal and natural gas over the time period shown in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/432/110432344.ipynb_qa_4"
+kaggle_dataset_name = "txtrouble/carbon-emissions"
+gold_answer = "-0.68"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "txtrouble__carbon-emissions"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "txtrouble/carbon-emissions"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.92"
+QUESTION = "What is the correlation coefficient between CO₂ emissions from coal and natural gas over the time period shown in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.02"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_563_110563506_qa_1/instruction.md b/tasks/0110_563_110563506_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9b05642efa41186f8acf7b3184056d3e28f81f04
--- /dev/null
+++ b/tasks/0110_563_110563506_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the Z-score of the top-selling game's North American sales compared to the mean North American sales?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_563_110563506_qa_1/task.toml b/tasks/0110_563_110563506_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e9784f55fe8d872e0b79851096fcc6068316041f
--- /dev/null
+++ b/tasks/0110_563_110563506_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0110_563_110563506_qa_1"
+description = "What is the Z-score of the top-selling game's North American sales compared to the mean North American sales?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/563/110563506.ipynb_qa_1"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "50.47898767479108"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "50.47898767479108"
+QUESTION = "What is the Z-score of the top-selling game's North American sales compared to the mean North American sales?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_615_110615404_qa_2/instruction.md b/tasks/0110_615_110615404_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..30a187fc804c06fe3ab8eea8d7a01ea1503b7966
--- /dev/null
+++ b/tasks/0110_615_110615404_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which species has the highest median petal length according to the bivariate analysis boxplots?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_615_110615404_qa_2/task.toml b/tasks/0110_615_110615404_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1626761bea7f809429bd8348fe10972ddc78002b
--- /dev/null
+++ b/tasks/0110_615_110615404_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0110_615_110615404_qa_2"
+description = "Which species has the highest median petal length according to the bivariate analysis boxplots?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/615/110615404.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "Iris-virginica"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Iris-virginica"
+QUESTION = "Which species has the highest median petal length according to the bivariate analysis boxplots?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_622_110622713_qa_2/instruction.md b/tasks/0110_622_110622713_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5daf7976c3c4b5ec774d378e8bdff19c3d64109
--- /dev/null
+++ b/tasks/0110_622_110622713_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest correlation coefficient between any feature and the diagnosis label in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_622_110622713_qa_2/task.toml b/tasks/0110_622_110622713_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f8577f49bbe900f35818d3d292d4e81d5a2a5723
--- /dev/null
+++ b/tasks/0110_622_110622713_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0110_622_110622713_qa_2"
+description = "What is the highest correlation coefficient between any feature and the diagnosis label in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/622/110622713.ipynb_qa_2"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "0.793566"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.793566"
+QUESTION = "What is the highest correlation coefficient between any feature and the diagnosis label in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_717_110717363_qa_1/instruction.md b/tasks/0110_717_110717363_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5222990987deddeb4b6280db03730d8dc6e6e0d3
--- /dev/null
+++ b/tasks/0110_717_110717363_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum sepal length in the entire dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_717_110717363_qa_1/task.toml b/tasks/0110_717_110717363_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..854a5a79f7164097f81a53f8cf9d2113acb4ffc8
--- /dev/null
+++ b/tasks/0110_717_110717363_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0110_717_110717363_qa_1"
+description = "What is the maximum sepal length in the entire dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/717/110717363.ipynb_qa_1"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "7.9"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "7.9"
+QUESTION = "What is the maximum sepal length in the entire dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_717_110717969_qa_1/instruction.md b/tasks/0110_717_110717969_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a7b64ea2020d8528f48fb301ce9441eb48ac8a8a
--- /dev/null
+++ b/tasks/0110_717_110717969_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which contract type is associated with the lowest churn probability according to the model coefficients?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_717_110717969_qa_1/task.toml b/tasks/0110_717_110717969_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d95630c4dc3490a40e0c9f27d7dbe4a2f9cfed48
--- /dev/null
+++ b/tasks/0110_717_110717969_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0110_717_110717969_qa_1"
+description = "Which contract type is associated with the lowest churn probability according to the model coefficients?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/717/110717969.ipynb_qa_1"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "Two year"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Two year"
+QUESTION = "Which contract type is associated with the lowest churn probability according to the model coefficients?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_118_112118657_qa_3/instruction.md b/tasks/0112_118_112118657_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2813f992149c9b647011bab0c755b21f0bf78564
--- /dev/null
+++ b/tasks/0112_118_112118657_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum median house value observed in the California housing dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_118_112118657_qa_3/task.toml b/tasks/0112_118_112118657_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f1c66791db32082ce9ad28ced451d62aa5c21b00
--- /dev/null
+++ b/tasks/0112_118_112118657_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0112_118_112118657_qa_3"
+description = "What is the maximum median house value observed in the California housing dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/118/112118657.ipynb_qa_3"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "500001"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "500001"
+QUESTION = "What is the maximum median house value observed in the California housing dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_172_112172227_qa_3/instruction.md b/tasks/0112_172_112172227_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c718b63ef7f71deaed2c3b7cd0b28f63f11ea4bd
--- /dev/null
+++ b/tasks/0112_172_112172227_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest standard deviation in the original dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_172_112172227_qa_3/task.toml b/tasks/0112_172_112172227_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5f86e4ae38284aec153663977dbdd002775bfe30
--- /dev/null
+++ b/tasks/0112_172_112172227_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0112_172_112172227_qa_3"
+description = "Which feature has the highest standard deviation in the original dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/172/112172227.ipynb_qa_3"
+kaggle_dataset_name = "saurabh00007/diabetescsv"
+gold_answer = "Insulin"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "saurabh00007__diabetescsv"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "saurabh00007/diabetescsv"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Insulin"
+QUESTION = "Which feature has the highest standard deviation in the original dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_571_112571521_qa_3/instruction.md b/tasks/0112_571_112571521_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d2d4f4c1b3896e92abb243577036e1d8eda3371e
--- /dev/null
+++ b/tasks/0112_571_112571521_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diamonds.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Based on the regression line analysis, which three numerical features showed the strongest linear relationships with diamond price before outlier removal?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the exact feature names.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_571_112571521_qa_3/task.toml b/tasks/0112_571_112571521_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c9a303b2a7fa81a61a4c99623ceac36fc5e1ec65
--- /dev/null
+++ b/tasks/0112_571_112571521_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0112_571_112571521_qa_3"
+description = "Based on the regression line analysis, which three numerical features showed the strongest linear relationships with diamond price before outlier removal?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/571/112571521.ipynb_qa_3"
+kaggle_dataset_name = "shivam2503/diamonds"
+gold_answer = "carat, x, y"
+reward_mode_initial = "list"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "shivam2503__diamonds"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "shivam2503/diamonds"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "carat, x, y"
+QUESTION = "Based on the regression line analysis, which three numerical features showed the strongest linear relationships with diamond price before outlier removal?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_571_112571521_qa_4/instruction.md b/tasks/0112_571_112571521_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6702f90f5f6a90d596b076d4f27fa9d0a3244c20
--- /dev/null
+++ b/tasks/0112_571_112571521_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diamonds.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which diamond cut category has the highest median price based on the violin plot analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_571_112571521_qa_4/task.toml b/tasks/0112_571_112571521_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..45348ce63a55dd33f5709120dfc871989a827a14
--- /dev/null
+++ b/tasks/0112_571_112571521_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0112_571_112571521_qa_4"
+description = "Which diamond cut category has the highest median price based on the violin plot analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/571/112571521.ipynb_qa_4"
+kaggle_dataset_name = "shivam2503/diamonds"
+gold_answer = "Fair"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "shivam2503__diamonds"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "shivam2503/diamonds"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Fair"
+QUESTION = "Which diamond cut category has the highest median price based on the violin plot analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_599_112599544_qa_2/instruction.md b/tasks/0112_599_112599544_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c8ccb5e3037c55196bbfa1a1041e91ede948ca07
--- /dev/null
+++ b/tasks/0112_599_112599544_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the standard deviation of the 'ram' feature in the dataset before normalization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_599_112599544_qa_2/task.toml b/tasks/0112_599_112599544_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..415a87134b2223b313a622457ca8bf6bbd0d73f3
--- /dev/null
+++ b/tasks/0112_599_112599544_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0112_599_112599544_qa_2"
+description = "What is the standard deviation of the 'ram' feature in the dataset before normalization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/599/112599544.ipynb_qa_2"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "1084.732044"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1084.732044"
+QUESTION = "What is the standard deviation of the 'ram' feature in the dataset before normalization?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_804_112804674_qa_2/instruction.md b/tasks/0112_804_112804674_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6246dda7faa7e7eda2c64be0b867a7222856456b
--- /dev/null
+++ b/tasks/0112_804_112804674_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- survey.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many unique gender categories were present in the dataset after feature engineering to standardize gender labels?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_804_112804674_qa_2/task.toml b/tasks/0112_804_112804674_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3d8209cca25ef43688bad0ac109aec7613b9b735
--- /dev/null
+++ b/tasks/0112_804_112804674_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0112_804_112804674_qa_2"
+description = "How many unique gender categories were present in the dataset after feature engineering to standardize gender labels?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/804/112804674.ipynb_qa_2"
+kaggle_dataset_name = "osmi/mental-health-in-tech-survey"
+gold_answer = "3"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "osmi__mental-health-in-tech-survey"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "osmi/mental-health-in-tech-survey"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3"
+QUESTION = "How many unique gender categories were present in the dataset after feature engineering to standardize gender labels?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_804_112804674_qa_3/instruction.md b/tasks/0112_804_112804674_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ec0d05eac0d9d369424286bba384ace6012e61a
--- /dev/null
+++ b/tasks/0112_804_112804674_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- survey.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which continent had the highest number of survey respondents in the cleaned dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_804_112804674_qa_3/task.toml b/tasks/0112_804_112804674_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..789264b02d4cda69f271d7a6b6e631fdbf596731
--- /dev/null
+++ b/tasks/0112_804_112804674_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0112_804_112804674_qa_3"
+description = "Which continent had the highest number of survey respondents in the cleaned dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/804/112804674.ipynb_qa_3"
+kaggle_dataset_name = "osmi/mental-health-in-tech-survey"
+gold_answer = "North America"
+reward_mode_initial = "exact_short"
+package_tier = 3
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "osmi__mental-health-in-tech-survey"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "osmi/mental-health-in-tech-survey"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "North America"
+QUESTION = "Which continent had the highest number of survey respondents in the cleaned dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_804_112804674_qa_4/instruction.md b/tasks/0112_804_112804674_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..63c41dee97632669882f35bf257e8b372aa54b68
--- /dev/null
+++ b/tasks/0112_804_112804674_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- survey.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many entries outside of the United States originally had non-null values in the "state" column before they were marked as "Irrelevant"?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_804_112804674_qa_4/task.toml b/tasks/0112_804_112804674_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..54545bac377b07e0d6c9551f2b6c970c85127e7a
--- /dev/null
+++ b/tasks/0112_804_112804674_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0112_804_112804674_qa_4"
+description = "How many entries outside of the United States originally had non-null values in the \"state\" column before they were marked as \"Irrelevant\"?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/804/112804674.ipynb_qa_4"
+kaggle_dataset_name = "osmi/mental-health-in-tech-survey"
+gold_answer = "4"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "osmi__mental-health-in-tech-survey"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "osmi/mental-health-in-tech-survey"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4"
+QUESTION = "How many entries outside of the United States originally had non-null values in the \"state\" column before they were marked as \"Irrelevant\"?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0112_804_112804674_qa_5/instruction.md b/tasks/0112_804_112804674_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8a533979fe706fbd338419f45d3a9935e39792db
--- /dev/null
+++ b/tasks/0112_804_112804674_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- survey.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the percentage of missing values in the "work_interfere" feature before data imputation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_804_112804674_qa_5/task.toml b/tasks/0112_804_112804674_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..eeb206dbe49763dd04f63723dfb196e3a09625d2
--- /dev/null
+++ b/tasks/0112_804_112804674_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0112_804_112804674_qa_5"
+description = "What was the percentage of missing values in the \"work_interfere\" feature before data imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/804/112804674.ipynb_qa_5"
+kaggle_dataset_name = "osmi/mental-health-in-tech-survey"
+gold_answer = "20.97"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "osmi__mental-health-in-tech-survey"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "osmi/mental-health-in-tech-survey"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "20.97"
+QUESTION = "What was the percentage of missing values in the \"work_interfere\" feature before data imputation?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0113_130_113130564_qa_2/instruction.md b/tasks/0113_130_113130564_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..daa78baa088001af1a047a93d53830b8e5cbc4e6
--- /dev/null
+++ b/tasks/0113_130_113130564_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- seattleWeather_1948-2017.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which year recorded the highest average precipitation according to the bar chart analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0113_130_113130564_qa_2/task.toml b/tasks/0113_130_113130564_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a26e3a3fe29e5e7fa89a961de8339b08a484803f
--- /dev/null
+++ b/tasks/0113_130_113130564_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0113_130_113130564_qa_2"
+description = "Which year recorded the highest average precipitation according to the bar chart analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0113/130/113130564.ipynb_qa_2"
+kaggle_dataset_name = "rtatman/did-it-rain-in-seattle-19482017"
+gold_answer = "1950"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rtatman__did-it-rain-in-seattle-19482017"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rtatman/did-it-rain-in-seattle-19482017"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1950"
+QUESTION = "Which year recorded the highest average precipitation according to the bar chart analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0113_346_113346497_qa_3/instruction.md b/tasks/0113_346_113346497_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..061c2883b461e5cb027ef68cc38d82124af39b48
--- /dev/null
+++ b/tasks/0113_346_113346497_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- database.sqlite
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which player in the Big 5 European leagues has the highest maximum overall rating, and what is that rating?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <player name>, <rating> (comma-separated, name first, rating as a plain number).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0113_346_113346497_qa_3/task.toml b/tasks/0113_346_113346497_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6d178e293e78a0b7c87c69c32171979a580b10b1
--- /dev/null
+++ b/tasks/0113_346_113346497_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0113_346_113346497_qa_3"
+description = "Which player in the Big 5 European leagues has the highest maximum overall rating, and what is that rating?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0113/346/113346497.ipynb_qa_3"
+kaggle_dataset_name = "hugomathien/soccer"
+gold_answer = "Lionel Messi, 94"
+reward_mode_initial = "list"
+package_tier = 3
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "hugomathien__soccer"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "hugomathien/soccer"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Lionel Messi, 94"
+QUESTION = "Which player in the Big 5 European leagues has the highest maximum overall rating, and what is that rating?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0113_431_113431641_qa_1/instruction.md b/tasks/0113_431_113431641_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2a26d502a28ce026c65205b2b7d8d68c04cd1e0c
--- /dev/null
+++ b/tasks/0113_431_113431641_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average increase in insurance charges for smokers compared to non-smokers according to the linear regression model?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0113_431_113431641_qa_1/task.toml b/tasks/0113_431_113431641_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7e6550420562fe42e464d359f3912e9daa044782
--- /dev/null
+++ b/tasks/0113_431_113431641_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0113_431_113431641_qa_1"
+description = "What is the average increase in insurance charges for smokers compared to non-smokers according to the linear regression model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0113/431/113431641.ipynb_qa_1"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "23600"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "23600"
+QUESTION = "What is the average increase in insurance charges for smokers compared to non-smokers according to the linear regression model?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0113_768_113768809_qa_2/instruction.md b/tasks/0113_768_113768809_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ecdc9076924cb3655346209fd4497d4246eee125
--- /dev/null
+++ b/tasks/0113_768_113768809_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+According to the Gradient Boosting model optimized for recall, which feature is the most important predictor of diabetes?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0113_768_113768809_qa_2/task.toml b/tasks/0113_768_113768809_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1e5396164efbabddc523f226bbd587152cec77b8
--- /dev/null
+++ b/tasks/0113_768_113768809_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0113_768_113768809_qa_2"
+description = "According to the Gradient Boosting model optimized for recall, which feature is the most important predictor of diabetes?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0113/768/113768809.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "According to the Gradient Boosting model optimized for recall, which feature is the most important predictor of diabetes?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0113_768_113768809_qa_5/instruction.md b/tasks/0113_768_113768809_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f50d8ecbb365daf5ce98701a55f8a03a904a18f0
--- /dev/null
+++ b/tasks/0113_768_113768809_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+According to the Random Forest model optimized for recall, which feature is the most important predictor of diabetes?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0113_768_113768809_qa_5/task.toml b/tasks/0113_768_113768809_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..974ebbab56ca34c678fd2e5e29cebca579d1b420
--- /dev/null
+++ b/tasks/0113_768_113768809_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0113_768_113768809_qa_5"
+description = "According to the Random Forest model optimized for recall, which feature is the most important predictor of diabetes?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0113/768/113768809.ipynb_qa_5"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "According to the Random Forest model optimized for recall, which feature is the most important predictor of diabetes?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0113_981_113981609_qa_5/instruction.md b/tasks/0113_981_113981609_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fdeffdda577b464123e4178b0d64c34214e014ec
--- /dev/null
+++ b/tasks/0113_981_113981609_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average Defense value of Pokémon in the fourth generation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0113_981_113981609_qa_5/task.toml b/tasks/0113_981_113981609_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cd5beebc9bda09663220bd66de91543f770d675e
--- /dev/null
+++ b/tasks/0113_981_113981609_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0113_981_113981609_qa_5"
+description = "What is the average Defense value of Pokémon in the fourth generation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0113/981/113981609.ipynb_qa_5"
+kaggle_dataset_name = "abcsds/pokemon"
+gold_answer = "78.13"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abcsds__pokemon"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abcsds/pokemon"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "78.13"
+QUESTION = "What is the average Defense value of Pokémon in the fourth generation?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0114_161_114161356_qa_4/instruction.md b/tasks/0114_161_114161356_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1b65281d714c551ed6ea6df72ba0de2362775fee
--- /dev/null
+++ b/tasks/0114_161_114161356_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the second most common video game genre in the dataset by frequency count?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0114_161_114161356_qa_4/task.toml b/tasks/0114_161_114161356_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..10307a41dd5b2ff151b0391a4434954ca3076660
--- /dev/null
+++ b/tasks/0114_161_114161356_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0114_161_114161356_qa_4"
+description = "What is the second most common video game genre in the dataset by frequency count?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0114/161/114161356.ipynb_qa_4"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Sports"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Sports"
+QUESTION = "What is the second most common video game genre in the dataset by frequency count?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0114_365_114365503_qa_5/instruction.md b/tasks/0114_365_114365503_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..832ea6562373f9f83072362f7ad656782f00914a
--- /dev/null
+++ b/tasks/0114_365_114365503_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- prices-split-adjusted.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average trading volume for Red Hat (RHT) in the filtered dataset according to the descriptive statistics?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0114_365_114365503_qa_5/task.toml b/tasks/0114_365_114365503_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1640d9ee0ee4ff50a8627581617fa61383969a3b
--- /dev/null
+++ b/tasks/0114_365_114365503_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0114_365_114365503_qa_5"
+description = "What is the average trading volume for Red Hat (RHT) in the filtered dataset according to the descriptive statistics?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0114/365/114365503.ipynb_qa_5"
+kaggle_dataset_name = "dgawlik/nyse"
+gold_answer = "2001894.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "dgawlik__nyse"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "dgawlik/nyse"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2001894.0"
+QUESTION = "What is the average trading volume for Red Hat (RHT) in the filtered dataset according to the descriptive statistics?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0114_582_114582781_qa_1/instruction.md b/tasks/0114_582_114582781_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f69b06145ca14a65a7c85dad34ad089fa2b3ee01
--- /dev/null
+++ b/tasks/0114_582_114582781_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the R² score of the linear regression model on the training data?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0114_582_114582781_qa_1/task.toml b/tasks/0114_582_114582781_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..eab61a8f75bade2e08c116f6c2f0ab40b39392ba
--- /dev/null
+++ b/tasks/0114_582_114582781_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0114_582_114582781_qa_1"
+description = "What is the R² score of the linear regression model on the training data?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0114/582/114582781.ipynb_qa_1"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "0.7497"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.7497"
+QUESTION = "What is the R² score of the linear regression model on the training data?"
+REWARD_MODE = "flexible"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0114_726_114726307_qa_4/instruction.md b/tasks/0114_726_114726307_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..212b978e2c650361fb4e008b2dfee9710c0ada52
--- /dev/null
+++ b/tasks/0114_726_114726307_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- accidents_2012_to_2014.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of recorded traffic accidents in the dataset for the year 2014 in the selected London boroughs (City of London and Westminster)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0114_726_114726307_qa_4/task.toml b/tasks/0114_726_114726307_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f5f97de37cc2ce93c5dad1fb32c17f89aefbb0e7
--- /dev/null
+++ b/tasks/0114_726_114726307_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0114_726_114726307_qa_4"
+description = "What is the total number of recorded traffic accidents in the dataset for the year 2014 in the selected London boroughs (City of London and Westminster)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0114/726/114726307.ipynb_qa_4"
+kaggle_dataset_name = "daveianhickey/2000-16-traffic-flow-england-scotland-wales"
+gold_answer = "1945"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "daveianhickey__2000-16-traffic-flow-england-scotland-wales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "daveianhickey/2000-16-traffic-flow-england-scotland-wales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1945"
+QUESTION = "What is the total number of recorded traffic accidents in the dataset for the year 2014 in the selected London boroughs (City of London and Westminster)?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0114_928_114928761_qa_5/instruction.md b/tasks/0114_928_114928761_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7f953c1fb167467ca6860cd5ad5570483c0cf444
--- /dev/null
+++ b/tasks/0114_928_114928761_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the F1-score for the positive class (Outcome = 1) in the model's classification report?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0114_928_114928761_qa_5/task.toml b/tasks/0114_928_114928761_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f189d75633f5f96f576d38d5e90ed3756fcc309e
--- /dev/null
+++ b/tasks/0114_928_114928761_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0114_928_114928761_qa_5"
+description = "What is the F1-score for the positive class (Outcome = 1) in the model's classification report?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0114/928/114928761.ipynb_qa_5"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "0.68"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.68"
+QUESTION = "What is the F1-score for the positive class (Outcome = 1) in the model's classification report?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0115_105_115105744_qa_2/instruction.md b/tasks/0115_105_115105744_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..da2fd4d3c064a49fb6faef8d10bc2b8fa3a25833
--- /dev/null
+++ b/tasks/0115_105_115105744_qa_2/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- test.csv
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the training dataset has the highest positive correlation with the price_range according to the Pearson correlation matrix?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0115_105_115105744_qa_2/task.toml b/tasks/0115_105_115105744_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..586c33ba8d754e9761ebf73c890050ad15ca8ad0
--- /dev/null
+++ b/tasks/0115_105_115105744_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0115_105_115105744_qa_2"
+description = "Which feature in the training dataset has the highest positive correlation with the price_range according to the Pearson correlation matrix?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0115/105/115105744.ipynb_qa_2"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "ram"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "ram"
+QUESTION = "Which feature in the training dataset has the highest positive correlation with the price_range according to the Pearson correlation matrix?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0115_105_115105744_qa_3/instruction.md b/tasks/0115_105_115105744_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..95d737aded4ac91b1d9611b963cade3bfb6e94ef
--- /dev/null
+++ b/tasks/0115_105_115105744_qa_3/instruction.md
@@ -0,0 +1,18 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- test.csv
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the distribution of price_range categories in the training dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as comma-separated <class>:<count> pairs.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0115_105_115105744_qa_3/task.toml b/tasks/0115_105_115105744_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b16fe6cb88703a52b9aab189adaad1738de02cf9
--- /dev/null
+++ b/tasks/0115_105_115105744_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0115_105_115105744_qa_3"
+description = "What is the distribution of price_range categories in the training dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0115/105/115105744.ipynb_qa_3"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "0:500,1:500,2:500,3:500"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0:500,1:500,2:500,3:500"
+QUESTION = "What is the distribution of price_range categories in the training dataset?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0115_907_115907821_qa_2/instruction.md b/tasks/0115_907_115907821_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..00c7cde9ee3ffd4fff2602e1624428d70ab68549
--- /dev/null
+++ b/tasks/0115_907_115907821_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total sum of all global sales values in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0115_907_115907821_qa_2/task.toml b/tasks/0115_907_115907821_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..367c43b1c19d4b764b94eb7542040ed90ec2e1a8
--- /dev/null
+++ b/tasks/0115_907_115907821_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0115_907_115907821_qa_2"
+description = "What is the total sum of all global sales values in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0115/907/115907821.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "8920.44"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "8920.44"
+QUESTION = "What is the total sum of all global sales values in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0115_907_115907821_qa_5/instruction.md b/tasks/0115_907_115907821_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a92dd64afe35a1d5ecaa9b399b0aed00cdbe9124
--- /dev/null
+++ b/tasks/0115_907_115907821_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the global sales value of the 5th highest selling video game in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0115_907_115907821_qa_5/task.toml b/tasks/0115_907_115907821_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..332577b87b553d06da937ab42b73eb984c8d7f03
--- /dev/null
+++ b/tasks/0115_907_115907821_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0115_907_115907821_qa_5"
+description = "What is the global sales value of the 5th highest selling video game in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0115/907/115907821.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "31.37"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "31.37"
+QUESTION = "What is the global sales value of the 5th highest selling video game in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0116_278_116278227_qa_3/instruction.md b/tasks/0116_278_116278227_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..98c281ec3c416654f26edb1c044e836d0cb94751
--- /dev/null
+++ b/tasks/0116_278_116278227_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the range of Age values observed in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0116_278_116278227_qa_3/task.toml b/tasks/0116_278_116278227_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c641799e4da1edd139fbadefe40273b763a790da
--- /dev/null
+++ b/tasks/0116_278_116278227_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0116_278_116278227_qa_3"
+description = "What is the range of Age values observed in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0116/278/116278227.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "21 to 81"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "21 to 81"
+QUESTION = "What is the range of Age values observed in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0116_278_116278227_qa_4/instruction.md b/tasks/0116_278_116278227_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..35024293f0c9c7ac7f740963091406609181582e
--- /dev/null
+++ b/tasks/0116_278_116278227_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median number of pregnancies for individuals with a BMI above 35?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0116_278_116278227_qa_4/task.toml b/tasks/0116_278_116278227_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..63298962270ca797b8d893b6ed46b2aa75d90307
--- /dev/null
+++ b/tasks/0116_278_116278227_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0116_278_116278227_qa_4"
+description = "What is the median number of pregnancies for individuals with a BMI above 35?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0116/278/116278227.ipynb_qa_4"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "3.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3.0"
+QUESTION = "What is the median number of pregnancies for individuals with a BMI above 35?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0116_564_116564780_qa_4/instruction.md b/tasks/0116_564_116564780_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..34842962c287dba6ed2f0ea4525841b83efd1d57
--- /dev/null
+++ b/tasks/0116_564_116564780_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many features in the dataset have a positive correlation of at least 0.2 with the wine quality label?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0116_564_116564780_qa_4/task.toml b/tasks/0116_564_116564780_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0991fb68b64a9af0fafd0aa86a4fd90d9929f4f8
--- /dev/null
+++ b/tasks/0116_564_116564780_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0116_564_116564780_qa_4"
+description = "How many features in the dataset have a positive correlation of at least 0.2 with the wine quality label?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0116/564/116564780.ipynb_qa_4"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "3"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3"
+QUESTION = "How many features in the dataset have a positive correlation of at least 0.2 with the wine quality label?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0116_621_116621192_qa_3/instruction.md b/tasks/0116_621_116621192_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..453388bbab99fc6888ad83f10895ff19201b360c
--- /dev/null
+++ b/tasks/0116_621_116621192_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median global sales value (in millions) for video games in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0116_621_116621192_qa_3/task.toml b/tasks/0116_621_116621192_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a71294ec7cc93247514c9335621824dd69f9324f
--- /dev/null
+++ b/tasks/0116_621_116621192_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0116_621_116621192_qa_3"
+description = "What is the median global sales value (in millions) for video games in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0116/621/116621192.ipynb_qa_3"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "0.17"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.17"
+QUESTION = "What is the median global sales value (in millions) for video games in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0116_621_116621192_qa_4/instruction.md b/tasks/0116_621_116621192_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f825985f23617f62eadb006a0e2fbed57ce8eb8
--- /dev/null
+++ b/tasks/0116_621_116621192_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which video game genre has the second-highest number of titles in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0116_621_116621192_qa_4/task.toml b/tasks/0116_621_116621192_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..48e564d30e32f02ee9f6fc968d0d809d6fe719e8
--- /dev/null
+++ b/tasks/0116_621_116621192_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0116_621_116621192_qa_4"
+description = "Which video game genre has the second-highest number of titles in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0116/621/116621192.ipynb_qa_4"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Sports"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Sports"
+QUESTION = "Which video game genre has the second-highest number of titles in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0116_643_116643019_qa_4/instruction.md b/tasks/0116_643_116643019_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e42ca78aa4067264b5ebcb091b670f3b6ecf8f04
--- /dev/null
+++ b/tasks/0116_643_116643019_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Does the video game sales dataset contain any rows where all columns except 'Rank' and 'Name' are null?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0116_643_116643019_qa_4/task.toml b/tasks/0116_643_116643019_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cd42532a9922b965704541314e1aca86a8dbd6a4
--- /dev/null
+++ b/tasks/0116_643_116643019_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0116_643_116643019_qa_4"
+description = "Does the video game sales dataset contain any rows where all columns except 'Rank' and 'Name' are null?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0116/643/116643019.ipynb_qa_4"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "no"
+reward_mode_initial = "exact_bool"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "no"
+QUESTION = "Does the video game sales dataset contain any rows where all columns except 'Rank' and 'Name' are null?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0117_519_117519892_qa_1/instruction.md b/tasks/0117_519_117519892_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bf30eff3cf5754e0406238ddefed575d5cdea46b
--- /dev/null
+++ b/tasks/0117_519_117519892_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of games in the Action genre according to the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0117_519_117519892_qa_1/task.toml b/tasks/0117_519_117519892_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b8d4b2660db5e4667782219bba78778ae2c8b020
--- /dev/null
+++ b/tasks/0117_519_117519892_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0117_519_117519892_qa_1"
+description = "What is the total number of games in the Action genre according to the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0117/519/117519892.ipynb_qa_1"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "3316"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3316"
+QUESTION = "What is the total number of games in the Action genre according to the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0117_685_117685347_qa_2/instruction.md b/tasks/0117_685_117685347_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b352779073bbc9f74e604ae350ef8c893778ab98
--- /dev/null
+++ b/tasks/0117_685_117685347_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the interquartile range (IQR) for citric acid content in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0117_685_117685347_qa_2/task.toml b/tasks/0117_685_117685347_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..aed3d299517e32fa9e00ed4b61825b2892cdf342
--- /dev/null
+++ b/tasks/0117_685_117685347_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0117_685_117685347_qa_2"
+description = "What is the interquartile range (IQR) for citric acid content in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0117/685/117685347.ipynb_qa_2"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "0.33"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.33"
+QUESTION = "What is the interquartile range (IQR) for citric acid content in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0117_685_117685347_qa_4/instruction.md b/tasks/0117_685_117685347_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a0ec9642ed3bb9c33c241113cddc3d85671f5cbc
--- /dev/null
+++ b/tasks/0117_685_117685347_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation threshold used to identify redundant features in the heatmap analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0117_685_117685347_qa_4/task.toml b/tasks/0117_685_117685347_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e7b7286197aa8d1e33f508789d4d99591aaa7586
--- /dev/null
+++ b/tasks/0117_685_117685347_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0117_685_117685347_qa_4"
+description = "What is the correlation threshold used to identify redundant features in the heatmap analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0117/685/117685347.ipynb_qa_4"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "0.7"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.7"
+QUESTION = "What is the correlation threshold used to identify redundant features in the heatmap analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0118_360_118360203_qa_5/instruction.md b/tasks/0118_360_118360203_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0d763eea0be91a2ee169e5644a0feea985b97435
--- /dev/null
+++ b/tasks/0118_360_118360203_qa_5/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+- test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum pixel height value observed in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0118_360_118360203_qa_5/task.toml b/tasks/0118_360_118360203_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..88ccab476b0b2d6d946e07cbe529c16068084b51
--- /dev/null
+++ b/tasks/0118_360_118360203_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0118_360_118360203_qa_5"
+description = "What is the maximum pixel height value observed in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0118/360/118360203.ipynb_qa_5"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "1960"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1960"
+QUESTION = "What is the maximum pixel height value observed in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0118_567_118567628_qa_5/instruction.md b/tasks/0118_567_118567628_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..94ad9665e8ca0ff3d248f205c1580d5c7e17ff30
--- /dev/null
+++ b/tasks/0118_567_118567628_qa_5/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Train.csv
+- Test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average Item_Outlet_Sales across all outlets in the training data?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0118_567_118567628_qa_5/task.toml b/tasks/0118_567_118567628_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1d70dfba1d50c58207b9df423e2a9de0ca168526
--- /dev/null
+++ b/tasks/0118_567_118567628_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0118_567_118567628_qa_5"
+description = "What is the average Item_Outlet_Sales across all outlets in the training data?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0118/567/118567628.ipynb_qa_5"
+kaggle_dataset_name = "devashish0507/big-mart-sales-prediction"
+gold_answer = "2181.288914"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "devashish0507__big-mart-sales-prediction"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "devashish0507/big-mart-sales-prediction"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2181.288914"
+QUESTION = "What is the average Item_Outlet_Sales across all outlets in the training data?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0118_722_118722407_qa_2/instruction.md b/tasks/0118_722_118722407_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..55ac98065ba5a38bd3380d4e51364efbc8ea3d0a
--- /dev/null
+++ b/tasks/0118_722_118722407_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Are all canceled orders in the dataset identified by InvoiceNo starting with 'C' and having a length of 7 characters, based on the hypothesis testing results?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0118_722_118722407_qa_2/task.toml b/tasks/0118_722_118722407_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8bfbba9945d47ac5081a5f33212486d6c134f8f9
--- /dev/null
+++ b/tasks/0118_722_118722407_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0118_722_118722407_qa_2"
+description = "Are all canceled orders in the dataset identified by InvoiceNo starting with 'C' and having a length of 7 characters, based on the hypothesis testing results?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0118/722/118722407.ipynb_qa_2"
+kaggle_dataset_name = "carrie1/ecommerce-data"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "carrie1__ecommerce-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "carrie1/ecommerce-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Are all canceled orders in the dataset identified by InvoiceNo starting with 'C' and having a length of 7 characters, based on the hypothesis testing results?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0118_978_118978270_qa_3/instruction.md b/tasks/0118_978_118978270_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..551e1c5772522c1fb66672e9443889365d49bae3
--- /dev/null
+++ b/tasks/0118_978_118978270_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature was identified as most important by the random forest classifier for predicting diabetes outcomes?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0118_978_118978270_qa_3/task.toml b/tasks/0118_978_118978270_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6dcd04078c656c7b910fa775d81986a46064c86d
--- /dev/null
+++ b/tasks/0118_978_118978270_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0118_978_118978270_qa_3"
+description = "Which feature was identified as most important by the random forest classifier for predicting diabetes outcomes?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0118/978/118978270.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "Which feature was identified as most important by the random forest classifier for predicting diabetes outcomes?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0119_783_119783005_qa_5/instruction.md b/tasks/0119_783_119783005_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d3c82565abf03bd66a2b57382862510e68e57ab
--- /dev/null
+++ b/tasks/0119_783_119783005_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Womens Clothing E-Commerce Reviews.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After applying SMOTE to address class imbalance, how many total samples are present in the resampled dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0119_783_119783005_qa_5/task.toml b/tasks/0119_783_119783005_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cc9e5bda77c84e1d24b771f3e0d452a004da5542
--- /dev/null
+++ b/tasks/0119_783_119783005_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0119_783_119783005_qa_5"
+description = "After applying SMOTE to address class imbalance, how many total samples are present in the resampled dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0119/783/119783005.ipynb_qa_5"
+kaggle_dataset_name = "nicapotato/womens-ecommerce-clothing-reviews"
+gold_answer = "38628"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "nicapotato__womens-ecommerce-clothing-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "nicapotato/womens-ecommerce-clothing-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "38628"
+QUESTION = "After applying SMOTE to address class imbalance, how many total samples are present in the resampled dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0119_931_119931935_qa_1/instruction.md b/tasks/0119_931_119931935_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3840156bb160297e071b8ac4bd50ff0029cd7584
--- /dev/null
+++ b/tasks/0119_931_119931935_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the dataset has the highest positive correlation with the diabetes outcome (Outcome=1)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0119_931_119931935_qa_1/task.toml b/tasks/0119_931_119931935_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cc30d687f79b630409f40e78fe8b8de24ab1851b
--- /dev/null
+++ b/tasks/0119_931_119931935_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0119_931_119931935_qa_1"
+description = "Which feature in the dataset has the highest positive correlation with the diabetes outcome (Outcome=1)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0119/931/119931935.ipynb_qa_1"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "Which feature in the dataset has the highest positive correlation with the diabetes outcome (Outcome=1)?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0119_971_119971188_qa_3/instruction.md b/tasks/0119_971_119971188_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e69cfc03bbc5d317207ea0fc81e0bf81d7d15519
--- /dev/null
+++ b/tasks/0119_971_119971188_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most frequent video game genre in the dataset based on the number of releases?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0119_971_119971188_qa_3/task.toml b/tasks/0119_971_119971188_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..80d3df8580be377e4488f791faff0d8a5d00e0c2
--- /dev/null
+++ b/tasks/0119_971_119971188_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0119_971_119971188_qa_3"
+description = "What is the most frequent video game genre in the dataset based on the number of releases?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0119/971/119971188.ipynb_qa_3"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Action"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Action"
+QUESTION = "What is the most frequent video game genre in the dataset based on the number of releases?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0120_102_120102768_qa_1/instruction.md b/tasks/0120_102_120102768_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bfd4ec2d33ed58f68b3522a6b5a8702b77be49f3
--- /dev/null
+++ b/tasks/0120_102_120102768_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest mean cross-validation accuracy achieved by any model on this dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0120_102_120102768_qa_1/task.toml b/tasks/0120_102_120102768_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..49ab18fedba0eb4de44ea157ceb625a8807d9dc2
--- /dev/null
+++ b/tasks/0120_102_120102768_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0120_102_120102768_qa_1"
+description = "What is the highest mean cross-validation accuracy achieved by any model on this dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0120/102/120102768.ipynb_qa_1"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "0.9789"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.9789"
+QUESTION = "What is the highest mean cross-validation accuracy achieved by any model on this dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0120_295_120295119_qa_5/instruction.md b/tasks/0120_295_120295119_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..47564546fe21240aeea8dddc0037e3d07f8025f6
--- /dev/null
+++ b/tasks/0120_295_120295119_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many features were removed during the backward feature selection process?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0120_295_120295119_qa_5/task.toml b/tasks/0120_295_120295119_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c52ebc92a24eed2104d68b2dd3e0023a6b327878
--- /dev/null
+++ b/tasks/0120_295_120295119_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0120_295_120295119_qa_5"
+description = "How many features were removed during the backward feature selection process?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0120/295/120295119.ipynb_qa_5"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "2"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2"
+QUESTION = "How many features were removed during the backward feature selection process?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0120_783_120783348_qa_3/instruction.md b/tasks/0120_783_120783348_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..341283ead45e733d8687d560ad6a9a409a6c25f2
--- /dev/null
+++ b/tasks/0120_783_120783348_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Social_Network_Ads.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which K value in the KNN model using raw data achieved the highest accuracy, and what was that accuracy score?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <K value>, <accuracy> (comma-separated, K value first, accuracy as a fraction e.g. 0.89).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0120_783_120783348_qa_3/task.toml b/tasks/0120_783_120783348_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1b7ddd23406f526dfa35679bd7c39e83c7aaa5d8
--- /dev/null
+++ b/tasks/0120_783_120783348_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0120_783_120783348_qa_3"
+description = "Which K value in the KNN model using raw data achieved the highest accuracy, and what was that accuracy score?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0120/783/120783348.ipynb_qa_3"
+kaggle_dataset_name = "rakeshrau/social-network-ads"
+gold_answer = "K=11, 0.89"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rakeshrau__social-network-ads"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rakeshrau/social-network-ads"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "K=11, 0.89"
+QUESTION = "Which K value in the KNN model using raw data achieved the highest accuracy, and what was that accuracy score?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0120_952_120952804_qa_4/instruction.md b/tasks/0120_952_120952804_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5de47a6a6281e106ccb2b9becb1c2bf9f7197fa1
--- /dev/null
+++ b/tasks/0120_952_120952804_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- PoliceKillingsUS.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most common manner of death in police killings as shown in the dataset visualizations?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0120_952_120952804_qa_4/task.toml b/tasks/0120_952_120952804_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c8aac54578a8f140d9c2864f6b641ca6f9bd2325
--- /dev/null
+++ b/tasks/0120_952_120952804_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0120_952_120952804_qa_4"
+description = "What is the most common manner of death in police killings as shown in the dataset visualizations?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0120/952/120952804.ipynb_qa_4"
+kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us"
+gold_answer = "Shot"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kwullum__fatal-police-shootings-in-the-us"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Shot"
+QUESTION = "What is the most common manner of death in police killings as shown in the dataset visualizations?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0121_046_121046676_qa_4/instruction.md b/tasks/0121_046_121046676_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f2118e1c23f6edbfa44af976cfdb601ace3c8085
--- /dev/null
+++ b/tasks/0121_046_121046676_qa_4/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- pokemon.csv
+- combats.csv
+- tests.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many missing values were present in the 'Type 2' column before imputation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0121_046_121046676_qa_4/task.toml b/tasks/0121_046_121046676_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0e589e3f1b304d32b7d845ecc838793ee8e8820f
--- /dev/null
+++ b/tasks/0121_046_121046676_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0121_046_121046676_qa_4"
+description = "How many missing values were present in the 'Type 2' column before imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0121/046/121046676.ipynb_qa_4"
+kaggle_dataset_name = "terminus7/pokemon-challenge"
+gold_answer = "386"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "terminus7__pokemon-challenge"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "386"
+QUESTION = "How many missing values were present in the 'Type 2' column before imputation?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0121_319_121319744_qa_1/instruction.md b/tasks/0121_319_121319744_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..55b1e9e121007240a51a54e5102ae5e3bc3f3970
--- /dev/null
+++ b/tasks/0121_319_121319744_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- mtcars.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the optimal number of clusters determined by the elbow method for the K-means clustering model on the car engine attributes dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0121_319_121319744_qa_1/task.toml b/tasks/0121_319_121319744_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4199d0a0be33d41feb9217c277fdce744a21618a
--- /dev/null
+++ b/tasks/0121_319_121319744_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0121_319_121319744_qa_1"
+description = "What is the optimal number of clusters determined by the elbow method for the K-means clustering model on the car engine attributes dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0121/319/121319744.ipynb_qa_1"
+kaggle_dataset_name = "ruiromanini/mtcars"
+gold_answer = "3"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ruiromanini__mtcars"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ruiromanini/mtcars"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3"
+QUESTION = "What is the optimal number of clusters determined by the elbow method for the K-means clustering model on the car engine attributes dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0121_588_121588240_qa_1/instruction.md b/tasks/0121_588_121588240_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c92526fb3015e70a31b36e62e833e05f117a4883
--- /dev/null
+++ b/tasks/0121_588_121588240_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the dataset shows the most distinct distribution across the three species when comparing box plots and histograms, based on the analysis presented in the notebook?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0121_588_121588240_qa_1/task.toml b/tasks/0121_588_121588240_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..684dee18b71cbdf47489572d58c29b1d3b3bf057
--- /dev/null
+++ b/tasks/0121_588_121588240_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0121_588_121588240_qa_1"
+description = "Which feature in the dataset shows the most distinct distribution across the three species when comparing box plots and histograms, based on the analysis presented in the notebook?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0121/588/121588240.ipynb_qa_1"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "PetalLengthCm"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "PetalLengthCm"
+QUESTION = "Which feature in the dataset shows the most distinct distribution across the three species when comparing box plots and histograms, based on the analysis presented in the notebook?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0121_738_121738149_qa_3/instruction.md b/tasks/0121_738_121738149_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7fe2b91a975684b518742f736291f098405b5791
--- /dev/null
+++ b/tasks/0121_738_121738149_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- kiva_loans.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which currency is used for the highest number of loans in the dataset, and how many loans are funded in that currency?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <currency>, <count> (comma-separated, label first, plain number).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0121_738_121738149_qa_3/task.toml b/tasks/0121_738_121738149_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1be7e37d8d4e519f28be247cd9860ec60f2b596f
--- /dev/null
+++ b/tasks/0121_738_121738149_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0121_738_121738149_qa_3"
+description = "Which currency is used for the highest number of loans in the dataset, and how many loans are funded in that currency?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0121/738/121738149.ipynb_qa_3"
+kaggle_dataset_name = "kiva/data-science-for-good-kiva-crowdfunding"
+gold_answer = "PHP, 160440"
+reward_mode_initial = "list"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kiva__data-science-for-good-kiva-crowdfunding"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kiva/data-science-for-good-kiva-crowdfunding"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "PHP, 160440"
+QUESTION = "Which currency is used for the highest number of loans in the dataset, and how many loans are funded in that currency?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0121_738_121738149_qa_5/instruction.md b/tasks/0121_738_121738149_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..301f56d739f78c1253c88254c366a948aa4fa7c7
--- /dev/null
+++ b/tasks/0121_738_121738149_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- kiva_loans.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which economic sector has the highest number of loans recorded in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0121_738_121738149_qa_5/task.toml b/tasks/0121_738_121738149_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f0d8106536a9b765136264f16f9c4a57895376e7
--- /dev/null
+++ b/tasks/0121_738_121738149_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0121_738_121738149_qa_5"
+description = "Which economic sector has the highest number of loans recorded in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0121/738/121738149.ipynb_qa_5"
+kaggle_dataset_name = "kiva/data-science-for-good-kiva-crowdfunding"
+gold_answer = "Agriculture"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kiva__data-science-for-good-kiva-crowdfunding"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kiva/data-science-for-good-kiva-crowdfunding"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Agriculture"
+QUESTION = "Which economic sector has the highest number of loans recorded in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0121_801_121801511_qa_3/instruction.md b/tasks/0121_801_121801511_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3dd6b971a81950cc290c05d24be27b1fd3ca9211
--- /dev/null
+++ b/tasks/0121_801_121801511_qa_3/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which combination of InternetService and Contract type results in the highest count of churned customers?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list with the InternetService label first, then the Contract label, using exact category names.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0121_801_121801511_qa_3/task.toml b/tasks/0121_801_121801511_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..98feee9d05223057929307b2a756e6732e7cbff8
--- /dev/null
+++ b/tasks/0121_801_121801511_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0121_801_121801511_qa_3"
+description = "Which combination of InternetService and Contract type results in the highest count of churned customers?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0121/801/121801511.ipynb_qa_3"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "Fiber optic, Month-to-month"
+reward_mode_initial = "list"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Fiber optic, Month-to-month"
+QUESTION = "Which combination of InternetService and Contract type results in the highest count of churned customers?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0121_801_121801511_qa_4/instruction.md b/tasks/0121_801_121801511_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2639321f531f4e07c6ba6123c37e890a7f4ef15e
--- /dev/null
+++ b/tasks/0121_801_121801511_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average monthly charge difference between churned and non-churned customers with Month-to-month contracts?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0121_801_121801511_qa_4/task.toml b/tasks/0121_801_121801511_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e5eb5ab56aef12079854d71825dc831dd4facb2d
--- /dev/null
+++ b/tasks/0121_801_121801511_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0121_801_121801511_qa_4"
+description = "What is the average monthly charge difference between churned and non-churned customers with Month-to-month contracts?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0121/801/121801511.ipynb_qa_4"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "11.56"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "11.56"
+QUESTION = "What is the average monthly charge difference between churned and non-churned customers with Month-to-month contracts?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0121_991_121991314_qa_5/instruction.md b/tasks/0121_991_121991314_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1177438fac83845eb8044229a6e593281fce4feb
--- /dev/null
+++ b/tasks/0121_991_121991314_qa_5/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Train.csv
+- Test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between Item_MRP and Item_Outlet_Sales in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0121_991_121991314_qa_5/task.toml b/tasks/0121_991_121991314_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8987e619f9126fab06b1b25275217860802aa26c
--- /dev/null
+++ b/tasks/0121_991_121991314_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0121_991_121991314_qa_5"
+description = "What is the correlation coefficient between Item_MRP and Item_Outlet_Sales in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0121/991/121991314.ipynb_qa_5"
+kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data"
+gold_answer = "0.59"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.59"
+QUESTION = "What is the correlation coefficient between Item_MRP and Item_Outlet_Sales in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0122_011_122011050_qa_1/instruction.md b/tasks/0122_011_122011050_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4ce5b39c3ed4398ed33e07f088b91cc8667a08f3
--- /dev/null
+++ b/tasks/0122_011_122011050_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train_u6lujuX_CVtuZ9i (1).csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest loan amount requested in the dataset after preprocessing?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0122_011_122011050_qa_1/task.toml b/tasks/0122_011_122011050_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fc934776e71def8431dc8478a680b72d594bb176
--- /dev/null
+++ b/tasks/0122_011_122011050_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0122_011_122011050_qa_1"
+description = "What is the highest loan amount requested in the dataset after preprocessing?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0122/011/122011050.ipynb_qa_1"
+kaggle_dataset_name = "ninzaami/loan-predication"
+gold_answer = "700.0"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ninzaami__loan-predication"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ninzaami/loan-predication"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "700.0"
+QUESTION = "What is the highest loan amount requested in the dataset after preprocessing?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0122_335_122335546_qa_1/instruction.md b/tasks/0122_335_122335546_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..af9986b0152776e5d8cf6d78d4355326a8cee539
--- /dev/null
+++ b/tasks/0122_335_122335546_qa_1/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+- test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature exhibits the strongest positive correlation with the price_range in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0122_335_122335546_qa_1/task.toml b/tasks/0122_335_122335546_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0d258afc171fbd70a497b49fd3299c6f7edd570f
--- /dev/null
+++ b/tasks/0122_335_122335546_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0122_335_122335546_qa_1"
+description = "Which feature exhibits the strongest positive correlation with the price_range in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0122/335/122335546.ipynb_qa_1"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "ram"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "ram"
+QUESTION = "Which feature exhibits the strongest positive correlation with the price_range in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0122_365_122365059_qa_2/instruction.md b/tasks/0122_365_122365059_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a8f14a11e36f212150aa0be022f6f2efe7e1bcfc
--- /dev/null
+++ b/tasks/0122_365_122365059_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which video game genre has the highest number of entries in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0122_365_122365059_qa_2/task.toml b/tasks/0122_365_122365059_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..31731ded275a647c5e7281b272ad76ac7819615a
--- /dev/null
+++ b/tasks/0122_365_122365059_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0122_365_122365059_qa_2"
+description = "Which video game genre has the highest number of entries in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0122/365/122365059.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Action"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Action"
+QUESTION = "Which video game genre has the highest number of entries in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0122_365_122365059_qa_3/instruction.md b/tasks/0122_365_122365059_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..16caa6364e085e2bba07d7b4e8d80ff09931fd05
--- /dev/null
+++ b/tasks/0122_365_122365059_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest global sales figure achieved by a single video game in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0122_365_122365059_qa_3/task.toml b/tasks/0122_365_122365059_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bf3288d6ca282517d43b86e145a2ff0f1a1e1ed0
--- /dev/null
+++ b/tasks/0122_365_122365059_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0122_365_122365059_qa_3"
+description = "What is the highest global sales figure achieved by a single video game in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0122/365/122365059.ipynb_qa_3"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "82.74"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "82.74"
+QUESTION = "What is the highest global sales figure achieved by a single video game in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0122_481_122481302_qa_5/instruction.md b/tasks/0122_481_122481302_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3e6eb22087590b487d65441f83ee0d47433cee64
--- /dev/null
+++ b/tasks/0122_481_122481302_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which education field has the highest number of employees who left the company based on the cross-tabulation results?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0122_481_122481302_qa_5/task.toml b/tasks/0122_481_122481302_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..491d738b5ccd7cd5fcadadd151f8a1eb3ea33292
--- /dev/null
+++ b/tasks/0122_481_122481302_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0122_481_122481302_qa_5"
+description = "Which education field has the highest number of employees who left the company based on the cross-tabulation results?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0122/481/122481302.ipynb_qa_5"
+kaggle_dataset_name = "patelprashant/employee-attrition"
+gold_answer = "Life Sciences"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "patelprashant__employee-attrition"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "patelprashant/employee-attrition"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Life Sciences"
+QUESTION = "Which education field has the highest number of employees who left the company based on the cross-tabulation results?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0122_770_122770918_qa_1/instruction.md b/tasks/0122_770_122770918_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..618ae60b4a23a07c0ca7116db33d228ff5d892a5
--- /dev/null
+++ b/tasks/0122_770_122770918_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- titanic_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the overall survival rate percentage of passengers in the Titanic dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0122_770_122770918_qa_1/task.toml b/tasks/0122_770_122770918_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5e45f69c11df9f55be5b6d336f4a1048730536e4
--- /dev/null
+++ b/tasks/0122_770_122770918_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0122_770_122770918_qa_1"
+description = "What is the overall survival rate percentage of passengers in the Titanic dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0122/770/122770918.ipynb_qa_1"
+kaggle_dataset_name = "abbasit/titanic"
+gold_answer = "38.38"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abbasit__titanic"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abbasit/titanic"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "38.38"
+QUESTION = "What is the overall survival rate percentage of passengers in the Titanic dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0123_397_123397782_qa_1/instruction.md b/tasks/0123_397_123397782_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4ddf540122f1142caa1567d8e6a02eb5fee60dbc
--- /dev/null
+++ b/tasks/0123_397_123397782_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference in the average number of characters between spam and ham messages in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0123_397_123397782_qa_1/task.toml b/tasks/0123_397_123397782_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ad53226b0d31f42c4578259155a7bfd5b10fac13
--- /dev/null
+++ b/tasks/0123_397_123397782_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0123_397_123397782_qa_1"
+description = "What is the difference in the average number of characters between spam and ham messages in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0123/397/123397782.ipynb_qa_1"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "67.43"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "67.43"
+QUESTION = "What is the difference in the average number of characters between spam and ham messages in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0123_676_123676836_qa_5/instruction.md b/tasks/0123_676_123676836_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..739e3b2607163b0bd1c7c7a48869377ba20601a1
--- /dev/null
+++ b/tasks/0123_676_123676836_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which video game genre has the highest number of produced games according to the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0123_676_123676836_qa_5/task.toml b/tasks/0123_676_123676836_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ec99cf102c09d8d989857c0b7447fe1eb14797be
--- /dev/null
+++ b/tasks/0123_676_123676836_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0123_676_123676836_qa_5"
+description = "Which video game genre has the highest number of produced games according to the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0123/676/123676836.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Action"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Action"
+QUESTION = "Which video game genre has the highest number of produced games according to the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0124_358_124358327_qa_3/instruction.md b/tasks/0124_358_124358327_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3bc2ebe091df2ecd0e48c24f4ff5d39e73576c96
--- /dev/null
+++ b/tasks/0124_358_124358327_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- kc_house_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the ratio of training data size to testing data size after dataset splitting?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0124_358_124358327_qa_3/task.toml b/tasks/0124_358_124358327_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f0a25282f8745b936a5b79884b7eec356f7996b4
--- /dev/null
+++ b/tasks/0124_358_124358327_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0124_358_124358327_qa_3"
+description = "What is the ratio of training data size to testing data size after dataset splitting?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0124/358/124358327.ipynb_qa_3"
+kaggle_dataset_name = "harlfoxem/housesalesprediction"
+gold_answer = "4:1"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "harlfoxem__housesalesprediction"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "4:1"
+QUESTION = "What is the ratio of training data size to testing data size after dataset splitting?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0124_418_124418283_qa_2/instruction.md b/tasks/0124_418_124418283_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..608813b9d3382b106b8ff761bcfe578cbe9c1be0
--- /dev/null
+++ b/tasks/0124_418_124418283_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many duplicate records were removed during the data preprocessing phase?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0124_418_124418283_qa_2/task.toml b/tasks/0124_418_124418283_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..de8c481e97bda5d56a60eaae66d600b87438b7cf
--- /dev/null
+++ b/tasks/0124_418_124418283_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0124_418_124418283_qa_2"
+description = "How many duplicate records were removed during the data preprocessing phase?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0124/418/124418283.ipynb_qa_2"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "240"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "240"
+QUESTION = "How many duplicate records were removed during the data preprocessing phase?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0124_418_124418283_qa_5/instruction.md b/tasks/0124_418_124418283_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ad2c4ffb5aa4e2b61667258a9beb56dfb8c8ebc8
--- /dev/null
+++ b/tasks/0124_418_124418283_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- winequality-red.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the final number of samples in the dataset after duplicate records were removed?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0124_418_124418283_qa_5/task.toml b/tasks/0124_418_124418283_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..000f8af7284a9c4676e7c1ecd65bf64dfafa04cd
--- /dev/null
+++ b/tasks/0124_418_124418283_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0124_418_124418283_qa_5"
+description = "What is the final number of samples in the dataset after duplicate records were removed?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0124/418/124418283.ipynb_qa_5"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "1359"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1359"
+QUESTION = "What is the final number of samples in the dataset after duplicate records were removed?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0125_140_125140765_qa_1/instruction.md b/tasks/0125_140_125140765_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f2f0fb8d140bc7537c223ec8acd6c0dde03cf5a8
--- /dev/null
+++ b/tasks/0125_140_125140765_qa_1/instruction.md
@@ -0,0 +1,19 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- MedianHouseholdIncome2015.csv
+- PercentagePeopleBelowPovertyLevel.csv
+- PercentOver25CompletedHighSchool.csv
+- ShareRaceByCity.csv
+- PoliceKillingsUS.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which U.S. state has the highest poverty rate according to the dataset analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0125_140_125140765_qa_1/task.toml b/tasks/0125_140_125140765_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ed06ffe8fcf1f9a48fcf71836d3f97fa522840bb
--- /dev/null
+++ b/tasks/0125_140_125140765_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0125_140_125140765_qa_1"
+description = "Which U.S. state has the highest poverty rate according to the dataset analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0125/140/125140765.ipynb_qa_1"
+kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us"
+gold_answer = "Mississippi"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kwullum__fatal-police-shootings-in-the-us"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Mississippi"
+QUESTION = "Which U.S. state has the highest poverty rate according to the dataset analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0125_188_125188137_qa_1/instruction.md b/tasks/0125_188_125188137_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..50a80c4781beb0d39ac5fef826b7b4ed69dcf37d
--- /dev/null
+++ b/tasks/0125_188_125188137_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- CC GENERAL.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which cluster has the highest average credit limit based on the Gaussian Mixture Model clustering results?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0125_188_125188137_qa_1/task.toml b/tasks/0125_188_125188137_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d324c06c32ff05a996153fd6349486df6ab529a6
--- /dev/null
+++ b/tasks/0125_188_125188137_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0125_188_125188137_qa_1"
+description = "Which cluster has the highest average credit limit based on the Gaussian Mixture Model clustering results?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0125/188/125188137.ipynb_qa_1"
+kaggle_dataset_name = "arjunbhasin2013/ccdata"
+gold_answer = "2"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "arjunbhasin2013__ccdata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "arjunbhasin2013/ccdata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2"
+QUESTION = "Which cluster has the highest average credit limit based on the Gaussian Mixture Model clustering results?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0125_427_125427363_qa_1/instruction.md b/tasks/0125_427_125427363_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b748843ddc01db715486af58bdc94f5aca21fd47
--- /dev/null
+++ b/tasks/0125_427_125427363_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- database.sqlite
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+In how many seasons was the Man of the Series also the Orange Cap winner?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0125_427_125427363_qa_1/task.toml b/tasks/0125_427_125427363_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c033a41b300301e05f0807fc4d0e52f5ded023bd
--- /dev/null
+++ b/tasks/0125_427_125427363_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0125_427_125427363_qa_1"
+description = "In how many seasons was the Man of the Series also the Orange Cap winner?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0125/427/125427363.ipynb_qa_1"
+kaggle_dataset_name = "harsha547/ipldatabase"
+gold_answer = "3"
+reward_mode_initial = "numeric"
+package_tier = 3
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "harsha547__ipldatabase"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "harsha547/ipldatabase"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3"
+QUESTION = "In how many seasons was the Man of the Series also the Orange Cap winner?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0126_180_126180239_qa_2/instruction.md b/tasks/0126_180_126180239_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d44631da13da0b00eb34c4da4becdf45c255714
--- /dev/null
+++ b/tasks/0126_180_126180239_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the name of the video game with the highest global sales for the Wii platform?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0126_180_126180239_qa_2/task.toml b/tasks/0126_180_126180239_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b7add34a7fd26dfb8e54013ad5215e4f2e71575e
--- /dev/null
+++ b/tasks/0126_180_126180239_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0126_180_126180239_qa_2"
+description = "What is the name of the video game with the highest global sales for the Wii platform?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0126/180/126180239.ipynb_qa_2"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Wii Sports"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Wii Sports"
+QUESTION = "What is the name of the video game with the highest global sales for the Wii platform?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0126_841_126841685_qa_2/instruction.md b/tasks/0126_841_126841685_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c82515a44d63edec001cfcb8d8482284afdbdd0a
--- /dev/null
+++ b/tasks/0126_841_126841685_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- titanic_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of passengers in the dataset survived the RMS Titanic disaster?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0126_841_126841685_qa_2/task.toml b/tasks/0126_841_126841685_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f12a3bcb06129219023762fe7207521f6f49e657
--- /dev/null
+++ b/tasks/0126_841_126841685_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0126_841_126841685_qa_2"
+description = "What percentage of passengers in the dataset survived the RMS Titanic disaster?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0126/841/126841685.ipynb_qa_2"
+kaggle_dataset_name = "abbasit/titanic"
+gold_answer = "38.38"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abbasit__titanic"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abbasit/titanic"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "38.38"
+QUESTION = "What percentage of passengers in the dataset survived the RMS Titanic disaster?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0126_841_126841685_qa_4/instruction.md b/tasks/0126_841_126841685_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..28569a574280e607b95019eae8b654cb23ad1d20
--- /dev/null
+++ b/tasks/0126_841_126841685_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- titanic_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many passengers had missing values in the Age column before imputation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0126_841_126841685_qa_4/task.toml b/tasks/0126_841_126841685_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4cd8daaa7ef76426a6b417de1526dffb0dc38c64
--- /dev/null
+++ b/tasks/0126_841_126841685_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0126_841_126841685_qa_4"
+description = "How many passengers had missing values in the Age column before imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0126/841/126841685.ipynb_qa_4"
+kaggle_dataset_name = "abbasit/titanic"
+gold_answer = "177"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "abbasit__titanic"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "abbasit/titanic"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "177"
+QUESTION = "How many passengers had missing values in the Age column before imputation?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0126_954_126954425_qa_3/instruction.md b/tasks/0126_954_126954425_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6466765c9e0243418ba5c48e4e9d873166004d33
--- /dev/null
+++ b/tasks/0126_954_126954425_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After standardization, what is the standard deviation of the 'BMI' feature in the processed dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0126_954_126954425_qa_3/task.toml b/tasks/0126_954_126954425_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0f3a954ddb2acfbeba99178ab45429659fc92cfc
--- /dev/null
+++ b/tasks/0126_954_126954425_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0126_954_126954425_qa_3"
+description = "After standardization, what is the standard deviation of the 'BMI' feature in the processed dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0126/954/126954425.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "1.000652"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.000652"
+QUESTION = "After standardization, what is the standard deviation of the 'BMI' feature in the processed dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0127_275_127275270_qa_1/instruction.md b/tasks/0127_275_127275270_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0c6491145c77b763692a322454f1c700e75e578
--- /dev/null
+++ b/tasks/0127_275_127275270_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- haberman.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Is there a statistically significant difference in the mean age between patients who survived 5 years or longer and those who died within 5 years based on the t-test results?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0127_275_127275270_qa_1/task.toml b/tasks/0127_275_127275270_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..507d726778a346d7eb32b6f925eab972c7efc824
--- /dev/null
+++ b/tasks/0127_275_127275270_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0127_275_127275270_qa_1"
+description = "Is there a statistically significant difference in the mean age between patients who survived 5 years or longer and those who died within 5 years based on the t-test results?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0127/275/127275270.ipynb_qa_1"
+kaggle_dataset_name = "gilsousa/habermans-survival-data-set"
+gold_answer = "no"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gilsousa__habermans-survival-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "no"
+QUESTION = "Is there a statistically significant difference in the mean age between patients who survived 5 years or longer and those who died within 5 years based on the t-test results?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0127_467_127467979_qa_4/instruction.md b/tasks/0127_467_127467979_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..9b97c47194f8586457809c8bb4cd0516892df04c
--- /dev/null
+++ b/tasks/0127_467_127467979_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which species has the smallest average petal length based on the dataset observations?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0127_467_127467979_qa_4/task.toml b/tasks/0127_467_127467979_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a349581ea59ceda3071d88d92bb12fa5d64a832f
--- /dev/null
+++ b/tasks/0127_467_127467979_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0127_467_127467979_qa_4"
+description = "Which species has the smallest average petal length based on the dataset observations?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0127/467/127467979.ipynb_qa_4"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "setosa"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "setosa"
+QUESTION = "Which species has the smallest average petal length based on the dataset observations?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0127_501_127501399_qa_3/instruction.md b/tasks/0127_501_127501399_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d0143496f91f87f2cc707bb4966eea77501b499d
--- /dev/null
+++ b/tasks/0127_501_127501399_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many unique categories were present in the "Item_Fat_Content" column before the replacement and normalization process?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0127_501_127501399_qa_3/task.toml b/tasks/0127_501_127501399_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..51265074e8938f62f36a0fddebfb1fca6e1472fc
--- /dev/null
+++ b/tasks/0127_501_127501399_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0127_501_127501399_qa_3"
+description = "How many unique categories were present in the \"Item_Fat_Content\" column before the replacement and normalization process?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0127/501/127501399.ipynb_qa_3"
+kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data"
+gold_answer = "5"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5"
+QUESTION = "How many unique categories were present in the \"Item_Fat_Content\" column before the replacement and normalization process?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0127_535_127535783_qa_4/instruction.md b/tasks/0127_535_127535783_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..83c91ac592f97f3174aa45203b0b94a40b79db90
--- /dev/null
+++ b/tasks/0127_535_127535783_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- web-Google.txt
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the damping factor (alpha) used in the custom PageRank computation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0127_535_127535783_qa_4/task.toml b/tasks/0127_535_127535783_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c3d364bb7690eaf15b5b7e4c1b79c4c15432ba10
--- /dev/null
+++ b/tasks/0127_535_127535783_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0127_535_127535783_qa_4"
+description = "What is the damping factor (alpha) used in the custom PageRank computation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0127/535/127535783.ipynb_qa_4"
+kaggle_dataset_name = "pappukrjha/google-web-graph"
+gold_answer = "0.85"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pappukrjha__google-web-graph"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pappukrjha/google-web-graph"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.85"
+QUESTION = "What is the damping factor (alpha) used in the custom PageRank computation?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0127_585_127585527_qa_4/instruction.md b/tasks/0127_585_127585527_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..028a185d447a391313fd78e5f69183a381c75da5
--- /dev/null
+++ b/tasks/0127_585_127585527_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- KAG_conversion_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the adjusted significance threshold (alpha) used for the Bonferroni correction in the A/B testing analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0127_585_127585527_qa_4/task.toml b/tasks/0127_585_127585527_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1b37029b0e739e3cfa7edb5027ddc2b935576b05
--- /dev/null
+++ b/tasks/0127_585_127585527_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0127_585_127585527_qa_4"
+description = "What is the adjusted significance threshold (alpha) used for the Bonferroni correction in the A/B testing analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0127/585/127585527.ipynb_qa_4"
+kaggle_dataset_name = "loveall/clicks-conversion-tracking"
+gold_answer = "0.01667"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "loveall__clicks-conversion-tracking"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "loveall/clicks-conversion-tracking"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.01667"
+QUESTION = "What is the adjusted significance threshold (alpha) used for the Bonferroni correction in the A/B testing analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0127_768_127768301_qa_3/instruction.md b/tasks/0127_768_127768301_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c9c15b22c0c370a826d7b1dcc584aca856535e5e
--- /dev/null
+++ b/tasks/0127_768_127768301_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which variable in the dataset shows the strongest visual association with diabetes diagnosis based on the pairplot analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0127_768_127768301_qa_3/task.toml b/tasks/0127_768_127768301_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..34943f2b424ed615d7c320c0a57f63a02aca30ac
--- /dev/null
+++ b/tasks/0127_768_127768301_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0127_768_127768301_qa_3"
+description = "Which variable in the dataset shows the strongest visual association with diabetes diagnosis based on the pairplot analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0127/768/127768301.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "Which variable in the dataset shows the strongest visual association with diabetes diagnosis based on the pairplot analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0127_821_127821175_qa_4/instruction.md b/tasks/0127_821_127821175_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0dc80a7175eee2d38917aaab329a4157868e3708
--- /dev/null
+++ b/tasks/0127_821_127821175_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- IMDB-Movie-Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which movie achieved the highest revenue in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0127_821_127821175_qa_4/task.toml b/tasks/0127_821_127821175_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4ae217fea7f9df17799dca8c94ca8f62050dcf58
--- /dev/null
+++ b/tasks/0127_821_127821175_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0127_821_127821175_qa_4"
+description = "Which movie achieved the highest revenue in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0127/821/127821175.ipynb_qa_4"
+kaggle_dataset_name = "PromptCloudHQ/imdb-data"
+gold_answer = "Star Wars: Episode VII - The Force Awakens"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "PromptCloudHQ__imdb-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "PromptCloudHQ/imdb-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Star Wars: Episode VII - The Force Awakens"
+QUESTION = "Which movie achieved the highest revenue in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0127_846_127846412_qa_2/instruction.md b/tasks/0127_846_127846412_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c6a6ad95658067017445120b915d7c6050ee612
--- /dev/null
+++ b/tasks/0127_846_127846412_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the absolute difference in average medical charges between smokers and non-smokers in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0127_846_127846412_qa_2/task.toml b/tasks/0127_846_127846412_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..64dc7407254dd97ae262fc7645cc6c3273590c02
--- /dev/null
+++ b/tasks/0127_846_127846412_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0127_846_127846412_qa_2"
+description = "What is the absolute difference in average medical charges between smokers and non-smokers in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0127/846/127846412.ipynb_qa_2"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "23609.57"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "23609.57"
+QUESTION = "What is the absolute difference in average medical charges between smokers and non-smokers in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0128_396_128396066_qa_1/instruction.md b/tasks/0128_396_128396066_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f7f9cc87497891cf72fc8227da4e99f21ac4312d
--- /dev/null
+++ b/tasks/0128_396_128396066_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the accuracy of the Decision Tree Classifier on the test set?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0128_396_128396066_qa_1/task.toml b/tasks/0128_396_128396066_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b5e2634e306fee38ffaf952fdc38c57c537cafcb
--- /dev/null
+++ b/tasks/0128_396_128396066_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0128_396_128396066_qa_1"
+description = "What is the accuracy of the Decision Tree Classifier on the test set?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0128/396/128396066.ipynb_qa_1"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "0.9473684210526315"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.9473684210526315"
+QUESTION = "What is the accuracy of the Decision Tree Classifier on the test set?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0128_929_128929154_qa_1/instruction.md b/tasks/0128_929_128929154_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f5878ab7083289a5e307257bc5025a66fac7a80b
--- /dev/null
+++ b/tasks/0128_929_128929154_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest correlation coefficient between any product category and the purchase amount in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0128_929_128929154_qa_1/task.toml b/tasks/0128_929_128929154_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fa66cbec18bc1c8b45fb24c2f63b31fd0f3b61a0
--- /dev/null
+++ b/tasks/0128_929_128929154_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0128_929_128929154_qa_1"
+description = "What is the highest correlation coefficient between any product category and the purchase amount in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0128/929/128929154.ipynb_qa_1"
+kaggle_dataset_name = "sdolezel/black-friday"
+gold_answer = "0.35"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "sdolezel__black-friday"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "sdolezel/black-friday"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.35"
+QUESTION = "What is the highest correlation coefficient between any product category and the purchase amount in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0128_954_128954233_qa_1/instruction.md b/tasks/0128_954_128954233_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..382261651caff36e4101acec1d4474b18d8ccda1
--- /dev/null
+++ b/tasks/0128_954_128954233_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest positive correlation coefficient between any two features in the dataset after converting the Species column to dummy variables?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0128_954_128954233_qa_1/task.toml b/tasks/0128_954_128954233_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..75c6ca0e94b63bc65aed5f186216656581aa7897
--- /dev/null
+++ b/tasks/0128_954_128954233_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0128_954_128954233_qa_1"
+description = "What is the highest positive correlation coefficient between any two features in the dataset after converting the Species column to dummy variables?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0128/954/128954233.ipynb_qa_1"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "0.962757"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.962757"
+QUESTION = "What is the highest positive correlation coefficient between any two features in the dataset after converting the Species column to dummy variables?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0129_603_129603179_qa_3/instruction.md b/tasks/0129_603_129603179_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..31cfcc8594ed9be578ac8eb35d41a3ee926b4d36
--- /dev/null
+++ b/tasks/0129_603_129603179_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-Telco-Customer-Churn.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the minimum value of the 'tenure' attribute after applying MinMaxScaler normalization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0129_603_129603179_qa_3/task.toml b/tasks/0129_603_129603179_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e29c0c1bcb4223db3b4f90c9f7fc5df60748c8f7
--- /dev/null
+++ b/tasks/0129_603_129603179_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0129_603_129603179_qa_3"
+description = "What is the minimum value of the 'tenure' attribute after applying MinMaxScaler normalization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0129/603/129603179.ipynb_qa_3"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "0"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0"
+QUESTION = "What is the minimum value of the 'tenure' attribute after applying MinMaxScaler normalization?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0129_784_129784913_qa_2/instruction.md b/tasks/0129_784_129784913_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e30e335225c729a6b19e1b7f318912de6d699bd9
--- /dev/null
+++ b/tasks/0129_784_129784913_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- AirPassengers.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the p-value of the Dickey-Fuller test for the residual component after seasonal decomposition of the time series?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0129_784_129784913_qa_2/task.toml b/tasks/0129_784_129784913_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..21deb049cdbb07782553b2bc97b5cf5d854b9b5e
--- /dev/null
+++ b/tasks/0129_784_129784913_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0129_784_129784913_qa_2"
+description = "What is the p-value of the Dickey-Fuller test for the residual component after seasonal decomposition of the time series?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0129/784/129784913.ipynb_qa_2"
+kaggle_dataset_name = "rakannimer/air-passengers"
+gold_answer = "2.885059e-08"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rakannimer__air-passengers"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rakannimer/air-passengers"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2.885059e-08"
+QUESTION = "What is the p-value of the Dickey-Fuller test for the residual component after seasonal decomposition of the time series?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0129_784_129784913_qa_3/instruction.md b/tasks/0129_784_129784913_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ec89425bb924c259556b180e24d3c11454619ba8
--- /dev/null
+++ b/tasks/0129_784_129784913_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- AirPassengers.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Is the original time series stationary at the 5% significance level based on the Dickey-Fuller test?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0129_784_129784913_qa_3/task.toml b/tasks/0129_784_129784913_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..433959e128e47fa6caee5df77d91df373bea0187
--- /dev/null
+++ b/tasks/0129_784_129784913_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0129_784_129784913_qa_3"
+description = "Is the original time series stationary at the 5% significance level based on the Dickey-Fuller test?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0129/784/129784913.ipynb_qa_3"
+kaggle_dataset_name = "rakannimer/air-passengers"
+gold_answer = "no"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rakannimer__air-passengers"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rakannimer/air-passengers"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "no"
+QUESTION = "Is the original time series stationary at the 5% significance level based on the Dickey-Fuller test?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0130_208_130208676_qa_4/instruction.md b/tasks/0130_208_130208676_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5f5fd16dd42a43ee6ba52573ee82745976797511
--- /dev/null
+++ b/tasks/0130_208_130208676_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- datafile (2).csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total production across all crops and years in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0130_208_130208676_qa_4/task.toml b/tasks/0130_208_130208676_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f94c62f36dd6b9b7a719633f44760ce333c04a97
--- /dev/null
+++ b/tasks/0130_208_130208676_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0130_208_130208676_qa_4"
+description = "What is the total production across all crops and years in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0130/208/130208676.ipynb_qa_4"
+kaggle_dataset_name = "srinivas1/agricuture-crops-production-in-india"
+gold_answer = "50336.6"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "srinivas1__agricuture-crops-production-in-india"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "srinivas1/agricuture-crops-production-in-india"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "50336.6"
+QUESTION = "What is the total production across all crops and years in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0131_438_131438357_qa_4/instruction.md b/tasks/0131_438_131438357_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4597ac6a4ca319f5494f4f80424d861f55102305
--- /dev/null
+++ b/tasks/0131_438_131438357_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- german_credit_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which decile contains the record with the maximum net profit according to the logistic regression model's analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0131_438_131438357_qa_4/task.toml b/tasks/0131_438_131438357_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ccb86fd806b2aaeb4ba8f75b76c2dc4e5c5c958f
--- /dev/null
+++ b/tasks/0131_438_131438357_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0131_438_131438357_qa_4"
+description = "Which decile contains the record with the maximum net profit according to the logistic regression model's analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0131/438/131438357.ipynb_qa_4"
+kaggle_dataset_name = "kabure/german-credit-data-with-risk"
+gold_answer = "1"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kabure__german-credit-data-with-risk"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kabure/german-credit-data-with-risk"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1"
+QUESTION = "Which decile contains the record with the maximum net profit according to the logistic regression model's analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0131_458_131458182_qa_5/instruction.md b/tasks/0131_458_131458182_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8dfcd9c9755886ea482c5feff9c240a68477fc5b
--- /dev/null
+++ b/tasks/0131_458_131458182_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many missing values are present in the 'market_category' column of the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0131_458_131458182_qa_5/task.toml b/tasks/0131_458_131458182_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3799ff54c5eb17a1dd7d4626cb18f8feaef04be7
--- /dev/null
+++ b/tasks/0131_458_131458182_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0131_458_131458182_qa_5"
+description = "How many missing values are present in the 'market_category' column of the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0131/458/131458182.ipynb_qa_5"
+kaggle_dataset_name = "CooperUnion/cardataset"
+gold_answer = "3742"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "CooperUnion__cardataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "CooperUnion/cardataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3742"
+QUESTION = "How many missing values are present in the 'market_category' column of the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0132_422_132422220_qa_2/instruction.md b/tasks/0132_422_132422220_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e0ff1a941392cb35540a659c42b43eb6e0ac9628
--- /dev/null
+++ b/tasks/0132_422_132422220_qa_2/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Social_Network_Ads.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of users in the dataset made a purchase?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Express the value as a percentage (e.g. 95.5), not a fraction.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0132_422_132422220_qa_2/task.toml b/tasks/0132_422_132422220_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2d88fe92632f2c4bf2ad05f17029c332283ddb6e
--- /dev/null
+++ b/tasks/0132_422_132422220_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0132_422_132422220_qa_2"
+description = "What percentage of users in the dataset made a purchase?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0132/422/132422220.ipynb_qa_2"
+kaggle_dataset_name = "dragonheir/logistic-regression"
+gold_answer = "35.75%"
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "dragonheir__logistic-regression"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "dragonheir/logistic-regression"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "35.75%"
+QUESTION = "What percentage of users in the dataset made a purchase?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0132_538_132538004_qa_5/instruction.md b/tasks/0132_538_132538004_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d2cadb3fc29604afe293066b3878b7270c39cf2
--- /dev/null
+++ b/tasks/0132_538_132538004_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which platform has the highest frequency of appearance in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0132_538_132538004_qa_5/task.toml b/tasks/0132_538_132538004_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b2dc3ab3438326bbbdf9925cdc60a9ba868d83e1
--- /dev/null
+++ b/tasks/0132_538_132538004_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0132_538_132538004_qa_5"
+description = "Which platform has the highest frequency of appearance in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0132/538/132538004.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "DS"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "DS"
+QUESTION = "Which platform has the highest frequency of appearance in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0133_522_133522334_qa_5/instruction.md b/tasks/0133_522_133522334_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bba71c9307911888cd8fddfd223be820a91933b3
--- /dev/null
+++ b/tasks/0133_522_133522334_qa_5/instruction.md
@@ -0,0 +1,17 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which department's Manager role has the highest average monthly income, and what is this value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <department>, <value> (comma-separated, label first, keep decimals).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0133_522_133522334_qa_5/task.toml b/tasks/0133_522_133522334_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c30dcdcee7aaaea921319bbf674946eb3eb7a0a5
--- /dev/null
+++ b/tasks/0133_522_133522334_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0133_522_133522334_qa_5"
+description = "Which department's Manager role has the highest average monthly income, and what is this value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0133/522/133522334.ipynb_qa_5"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "Human Resources, 18088.64"
+reward_mode_initial = "list"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Human Resources, 18088.64"
+QUESTION = "Which department's Manager role has the highest average monthly income, and what is this value?"
+REWARD_MODE = "list"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0134_445_134445739_qa_2/instruction.md b/tasks/0134_445_134445739_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c90c6e684a3365509bc3f0ad93687d299314175f
--- /dev/null
+++ b/tasks/0134_445_134445739_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- insurance.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which geographic region has the highest average medical insurance charges according to the training data?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0134_445_134445739_qa_2/task.toml b/tasks/0134_445_134445739_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..877bab254516f814aa7fddbc1bd5a4909c08f624
--- /dev/null
+++ b/tasks/0134_445_134445739_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0134_445_134445739_qa_2"
+description = "Which geographic region has the highest average medical insurance charges according to the training data?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0134/445/134445739.ipynb_qa_2"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "southeast"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "southeast"
+QUESTION = "Which geographic region has the highest average medical insurance charges according to the training data?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0135_324_135324126_qa_2/instruction.md b/tasks/0135_324_135324126_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..00b153c105e0dee354843864e7a201c0102cb6e6
--- /dev/null
+++ b/tasks/0135_324_135324126_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Is there a statistically significant difference in mean glucose levels between individuals with and without diabetes in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0135_324_135324126_qa_2/task.toml b/tasks/0135_324_135324126_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..206e4e92e0e5a283dc095911392a2fb3b4dc4634
--- /dev/null
+++ b/tasks/0135_324_135324126_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0135_324_135324126_qa_2"
+description = "Is there a statistically significant difference in mean glucose levels between individuals with and without diabetes in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0135/324/135324126.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Is there a statistically significant difference in mean glucose levels between individuals with and without diabetes in the dataset?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0135_324_135324126_qa_3/instruction.md b/tasks/0135_324_135324126_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4bdc48cd4030ac073a5b2fb4920fba06f9d1f2b2
--- /dev/null
+++ b/tasks/0135_324_135324126_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which physiological parameter (skin thickness or blood pressure) shows a statistically significant difference between individuals with and without diabetes according to the t-test results?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0135_324_135324126_qa_3/task.toml b/tasks/0135_324_135324126_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9fb9ae71fcf56bcd8c57b6d0aa7edd35fb401c72
--- /dev/null
+++ b/tasks/0135_324_135324126_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0135_324_135324126_qa_3"
+description = "Which physiological parameter (skin thickness or blood pressure) shows a statistically significant difference between individuals with and without diabetes according to the t-test results?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0135/324/135324126.ipynb_qa_3"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Skin Thickness"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Skin Thickness"
+QUESTION = "Which physiological parameter (skin thickness or blood pressure) shows a statistically significant difference between individuals with and without diabetes according to the t-test results?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0135_324_135324126_qa_5/instruction.md b/tasks/0135_324_135324126_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ebf80addd0bcb6a9096db2389cea7d9ca4af4248
--- /dev/null
+++ b/tasks/0135_324_135324126_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Is there a statistically significant difference in average age between individuals with diabetes and those without diabetes in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0135_324_135324126_qa_5/task.toml b/tasks/0135_324_135324126_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..62d203ea0afaeb998908dad3fd2b22040715b2e2
--- /dev/null
+++ b/tasks/0135_324_135324126_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0135_324_135324126_qa_5"
+description = "Is there a statistically significant difference in average age between individuals with diabetes and those without diabetes in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0135/324/135324126.ipynb_qa_5"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Is there a statistically significant difference in average age between individuals with diabetes and those without diabetes in the dataset?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0135_380_135380654_qa_2/instruction.md b/tasks/0135_380_135380654_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6bbc765f067c508ca5d1cc8182ba7ed14f0e3c64
--- /dev/null
+++ b/tasks/0135_380_135380654_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Life Expectancy Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean life expectancy in developed countries based on the sample data used for the hypothesis test?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0135_380_135380654_qa_2/task.toml b/tasks/0135_380_135380654_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..01cf9cb59b4e1ecf66d29449dd34ebcb90a017f7
--- /dev/null
+++ b/tasks/0135_380_135380654_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0135_380_135380654_qa_2"
+description = "What is the mean life expectancy in developed countries based on the sample data used for the hypothesis test?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0135/380/135380654.ipynb_qa_2"
+kaggle_dataset_name = "kumarajarshi/life-expectancy-who"
+gold_answer = "78.808"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kumarajarshi__life-expectancy-who"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "78.808"
+QUESTION = "What is the mean life expectancy in developed countries based on the sample data used for the hypothesis test?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0135_380_135380654_qa_4/instruction.md b/tasks/0135_380_135380654_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..be60ef6dcdbba5f5b310d22f51b2d6d480cb9cb6
--- /dev/null
+++ b/tasks/0135_380_135380654_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Life Expectancy Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Based on the p-value and a significance level of 0.05, is there sufficient evidence to reject the null hypothesis that the mean life expectancies are equal between developing and developed countries?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0135_380_135380654_qa_4/task.toml b/tasks/0135_380_135380654_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f402a8b3dc84c4ee1b0ea1ec5cf8d3e21a2aae8b
--- /dev/null
+++ b/tasks/0135_380_135380654_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0135_380_135380654_qa_4"
+description = "Based on the p-value and a significance level of 0.05, is there sufficient evidence to reject the null hypothesis that the mean life expectancies are equal between developing and developed countries?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0135/380/135380654.ipynb_qa_4"
+kaggle_dataset_name = "kumarajarshi/life-expectancy-who"
+gold_answer = "yes"
+reward_mode_initial = "exact_bool"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kumarajarshi__life-expectancy-who"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "yes"
+QUESTION = "Based on the p-value and a significance level of 0.05, is there sufficient evidence to reject the null hypothesis that the mean life expectancies are equal between developing and developed countries?"
+REWARD_MODE = "exact_bool"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0136_044_136044627_qa_5/instruction.md b/tasks/0136_044_136044627_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0ef9367b55c18a1902f2c3b1493324c4e7adb09
--- /dev/null
+++ b/tasks/0136_044_136044627_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Iris.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the standard deviation of the Petal Width measurements in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0136_044_136044627_qa_5/task.toml b/tasks/0136_044_136044627_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c114ff6119674ff40ced0ebd2177da290afdaa2f
--- /dev/null
+++ b/tasks/0136_044_136044627_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0136_044_136044627_qa_5"
+description = "What is the standard deviation of the Petal Width measurements in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0136/044/136044627.ipynb_qa_5"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "0.763161"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+difficulty_tier = "easy"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.763161"
+QUESTION = "What is the standard deviation of the Petal Width measurements in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0136_157_136157860_qa_5/instruction.md b/tasks/0136_157_136157860_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ba0eb309342e1582b0b115e0594ee4f7632e26fc
--- /dev/null
+++ b/tasks/0136_157_136157860_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train_u6lujuX_CVtuZ9i (1).csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many loan applications are present in the dataset after removing all rows with missing values?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0136_157_136157860_qa_5/task.toml b/tasks/0136_157_136157860_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..68113ce60567b22f96d2050e9496c3bd6ed2c595
--- /dev/null
+++ b/tasks/0136_157_136157860_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0136_157_136157860_qa_5"
+description = "How many loan applications are present in the dataset after removing all rows with missing values?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0136/157/136157860.ipynb_qa_5"
+kaggle_dataset_name = "ninzaami/loan-predication"
+gold_answer = "480"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ninzaami__loan-predication"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ninzaami/loan-predication"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "480"
+QUESTION = "How many loan applications are present in the dataset after removing all rows with missing values?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0136_198_136198797_qa_2/instruction.md b/tasks/0136_198_136198797_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bc7ee73811e826f69b9b0a9ba43cd13c8e7a9a1c
--- /dev/null
+++ b/tasks/0136_198_136198797_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the most frequent ocean proximity category in the training dataset after removing rows with missing values?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0136_198_136198797_qa_2/task.toml b/tasks/0136_198_136198797_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..55cfa07c31ed64360e2eb1d2fbbe7dac8b003b65
--- /dev/null
+++ b/tasks/0136_198_136198797_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0136_198_136198797_qa_2"
+description = "What is the most frequent ocean proximity category in the training dataset after removing rows with missing values?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0136/198/136198797.ipynb_qa_2"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "<1H OCEAN"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "<1H OCEAN"
+QUESTION = "What is the most frequent ocean proximity category in the training dataset after removing rows with missing values?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0136_845_136845893_qa_4/instruction.md b/tasks/0136_845_136845893_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..03d43f104387c049a64d9a621881a84f3cefe8cd
--- /dev/null
+++ b/tasks/0136_845_136845893_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- spam.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After implementing class balancing, what is the exact ratio of ham to spam messages in the balanced training dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0136_845_136845893_qa_4/task.toml b/tasks/0136_845_136845893_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ec34e2a22013570cbe01587fe877edca7beb09f0
--- /dev/null
+++ b/tasks/0136_845_136845893_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0136_845_136845893_qa_4"
+description = "After implementing class balancing, what is the exact ratio of ham to spam messages in the balanced training dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0136/845/136845893.ipynb_qa_4"
+kaggle_dataset_name = "uciml/sms-spam-collection-dataset"
+gold_answer = "1:1"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 3
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__sms-spam-collection-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1:1"
+QUESTION = "After implementing class balancing, what is the exact ratio of ham to spam messages in the balanced training dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0138_302_138302934_qa_3/instruction.md b/tasks/0138_302_138302934_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0f331aecb3fbccb860895df5b8d63d57c2186563
--- /dev/null
+++ b/tasks/0138_302_138302934_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- HR_comma_sep.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference in average monthly working hours between employees who left and those who remained?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0138_302_138302934_qa_3/task.toml b/tasks/0138_302_138302934_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8676418da404b01ee12b99314b6485f87edab638
--- /dev/null
+++ b/tasks/0138_302_138302934_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0138_302_138302934_qa_3"
+description = "What is the difference in average monthly working hours between employees who left and those who remained?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0138/302/138302934.ipynb_qa_3"
+kaggle_dataset_name = "giripujar/hr-analytics"
+gold_answer = "8.36"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "giripujar__hr-analytics"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "giripujar/hr-analytics"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "8.36"
+QUESTION = "What is the difference in average monthly working hours between employees who left and those who remained?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0138_805_138805260_qa_1/instruction.md b/tasks/0138_805_138805260_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d28c896f91b84938065b9f85f39df7b05889fa0
--- /dev/null
+++ b/tasks/0138_805_138805260_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- 50_Startups.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest importance in the Random Forest model based on feature importance analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0138_805_138805260_qa_1/task.toml b/tasks/0138_805_138805260_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7822227c8550b85619d8fb95a645ad9179754c65
--- /dev/null
+++ b/tasks/0138_805_138805260_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0138_805_138805260_qa_1"
+description = "Which feature has the highest importance in the Random Forest model based on feature importance analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0138/805/138805260.ipynb_qa_1"
+kaggle_dataset_name = "karthickveerakumar/startup-logistic-regression"
+gold_answer = "R&D Spend"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 4
+difficulty_tier = "hard"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "karthickveerakumar__startup-logistic-regression"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "karthickveerakumar/startup-logistic-regression"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "R&D Spend"
+QUESTION = "Which feature has the highest importance in the Random Forest model based on feature importance analysis?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0139_103_139103748_qa_4/instruction.md b/tasks/0139_103_139103748_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cdd9b98a5f807c26344036103ad5bf53c56b2bed
--- /dev/null
+++ b/tasks/0139_103_139103748_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the original dataset (before scaling) has the highest variability as measured by standard deviation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0139_103_139103748_qa_4/task.toml b/tasks/0139_103_139103748_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..64fe3c973df62743b0468021c8064deb84f8f8a9
--- /dev/null
+++ b/tasks/0139_103_139103748_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0139_103_139103748_qa_4"
+description = "Which feature in the original dataset (before scaling) has the highest variability as measured by standard deviation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0139/103/139103748.ipynb_qa_4"
+kaggle_dataset_name = "vikrishnan/boston-house-prices"
+gold_answer = "TAX"
+reward_mode_initial = "exact_short"
+package_tier = 2
+difficulty_level = 2
+difficulty_tier = "medium"
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "vikrishnan__boston-house-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "vikrishnan/boston-house-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "TAX"
+QUESTION = "Which feature in the original dataset (before scaling) has the highest variability as measured by standard deviation?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]