diff --git a/tasks/0001_604_1604140_qa_2/instruction.md b/tasks/0001_604_1604140_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6a041d1e3133410afc53bb82341337d49a5c5fc4
--- /dev/null
+++ b/tasks/0001_604_1604140_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:
+Which U.S. state has the highest number of recorded mass shootings between 2010 and 2017 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/0001_664_1664478_qa_1/instruction.md b/tasks/0001_664_1664478_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8d66d97969046e14a141260a9c5bf19dab536884
--- /dev/null
+++ b/tasks/0001_664_1664478_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):
+- cereal.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which manufacturer has the highest number of cereal products 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_664_1664478_qa_1/task.toml b/tasks/0001_664_1664478_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..223e585ed0c894d92d398216bea48c76738c73d5
--- /dev/null
+++ b/tasks/0001_664_1664478_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0001_664_1664478_qa_1"
+description = "Which manufacturer has the highest number of cereal products in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/664/1664478.ipynb_qa_1"
+kaggle_dataset_name = "crawford/80-cereals"
+gold_answer = "K"
+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 = "crawford__80-cereals"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crawford/80-cereals"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "K"
+QUESTION = "Which manufacturer has the highest number of cereal products 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/0001_840_1840182_qa_4/instruction.md b/tasks/0001_840_1840182_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb3f17ac4a4183490d15bd2734d5ab36942a728b
--- /dev/null
+++ b/tasks/0001_840_1840182_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):
+- 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 wine variety with the largest number of 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/0001_840_1840182_qa_4/task.toml b/tasks/0001_840_1840182_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f23a29c53dc27b5f330c3a26e36796c9fed0b657
--- /dev/null
+++ b/tasks/0001_840_1840182_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_840_1840182_qa_4"
+description = "What is the wine variety with the largest number of reviews in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/840/1840182.ipynb_qa_4"
+kaggle_dataset_name = "zynicide/wine-reviews"
+gold_answer = "Pinot Noir"
+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 = "zynicide__wine-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zynicide/wine-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Pinot Noir"
+QUESTION = "What is the wine variety with the largest number of 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/0001_878_1878746_qa_4/instruction.md b/tasks/0001_878_1878746_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8d40bf15009308312983baf1302e5d1919a424d1
--- /dev/null
+++ b/tasks/0001_878_1878746_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:
+What is the maximum sodium content found in any cereal 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_878_1878746_qa_4/task.toml b/tasks/0001_878_1878746_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4ecb2a899a7c07418a7677b51ed19145fa77089a
--- /dev/null
+++ b/tasks/0001_878_1878746_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0001_878_1878746_qa_4"
+description = "What is the maximum sodium content found in any cereal in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/878/1878746.ipynb_qa_4"
+kaggle_dataset_name = "crawford/80-cereals"
+gold_answer = "320"
+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 = "crawford__80-cereals"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crawford/80-cereals"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "320"
+QUESTION = "What is the maximum sodium content found in any cereal 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_990_1990794_qa_2/instruction.md b/tasks/0001_990_1990794_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2f175909c58961e47725caa4ccf286040b25f002
--- /dev/null
+++ b/tasks/0001_990_1990794_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):
+- 911_calls_for_service.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which priority level has the highest percentage of calls 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_990_1990794_qa_2/task.toml b/tasks/0001_990_1990794_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..74ca44e830e12246e8a62f12c88bff1e28387401
--- /dev/null
+++ b/tasks/0001_990_1990794_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0001_990_1990794_qa_2"
+description = "Which priority level has the highest percentage of calls in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/990/1990794.ipynb_qa_2"
+kaggle_dataset_name = "sohier/baltimore-911-calls"
+gold_answer = "Medium"
+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 = "sohier__baltimore-911-calls"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "sohier/baltimore-911-calls"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Medium"
+QUESTION = "Which priority level has the highest percentage of calls 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/0010_191_10191909_qa_1/instruction.md b/tasks/0010_191_10191909_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca4467a6c8ac5e48433e931736992477f7c5b0dc
--- /dev/null
+++ b/tasks/0010_191_10191909_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 tumors 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/0010_191_10191909_qa_1/task.toml b/tasks/0010_191_10191909_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f9c6cd4df6bafb5d312e211abeffb9721a11423b
--- /dev/null
+++ b/tasks/0010_191_10191909_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0010_191_10191909_qa_1"
+description = "What is the percentage of benign tumors in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0010/191/10191909.ipynb_qa_1"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "62.7417"
+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 = "62.7417"
+QUESTION = "What is the percentage of benign tumors 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/0012_593_12593899_qa_2/instruction.md b/tasks/0012_593_12593899_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..995961a9430454154092b3bc983874a16b79f527
--- /dev/null
+++ b/tasks/0012_593_12593899_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):
+- crime.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which day of the month has the highest crime rate 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/0012_593_12593899_qa_2/task.toml b/tasks/0012_593_12593899_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..55dc61bdaf8bcbc73d55d1b2826d3195d239fc38
--- /dev/null
+++ b/tasks/0012_593_12593899_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0012_593_12593899_qa_2"
+description = "Which day of the month has the highest crime rate based on the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0012/593/12593899.ipynb_qa_2"
+kaggle_dataset_name = "wosaku/crime-in-vancouver"
+gold_answer = "1"
+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 = "wosaku__crime-in-vancouver"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "wosaku/crime-in-vancouver"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1"
+QUESTION = "Which day of the month has the highest crime rate based on 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/0014_390_14390255_qa_5/instruction.md b/tasks/0014_390_14390255_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..93337e8afceb200925632c4edde426571aa9d164
--- /dev/null
+++ b/tasks/0014_390_14390255_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):
+- student-mat.csv
+- student-por.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 Portuguese dataset have parents who live together (Pstatus=T)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_390_14390255_qa_5/task.toml b/tasks/0014_390_14390255_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0588c247f18eb8f0a33781aa28076321723f7024
--- /dev/null
+++ b/tasks/0014_390_14390255_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0014_390_14390255_qa_5"
+description = "What percentage of students in the Portuguese dataset have parents who live together (Pstatus=T)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0014/390/14390255.ipynb_qa_5"
+kaggle_dataset_name = "uciml/student-alcohol-consumption"
+gold_answer = "87.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 = "uciml__student-alcohol-consumption"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "87.67"
+QUESTION = "What percentage of students in the Portuguese dataset have parents who live together (Pstatus=T)?"
+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_945_16945752_qa_5/instruction.md b/tasks/0016_945_16945752_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7e9242a47a2f3078fa25d1e33660a684f1c5cfcc
--- /dev/null
+++ b/tasks/0016_945_16945752_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):
+- haberman.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 axillary node counts for patients who survived versus those who did not?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <survived_std>, <not_survived_std> (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/0016_945_16945752_qa_5/task.toml b/tasks/0016_945_16945752_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e003913268e23a0dff423abe4e654c392404d47e
--- /dev/null
+++ b/tasks/0016_945_16945752_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0016_945_16945752_qa_5"
+description = "What is the standard deviation of axillary node counts for patients who survived versus 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_5"
+kaggle_dataset_name = "gilsousa/habermans-survival-data-set"
+gold_answer = "5.86, 9.13"
+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 = "5.86, 9.13"
+QUESTION = "What is the standard deviation of axillary node counts for patients who survived versus those who did not?"
+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/0016_971_16971389_qa_1/instruction.md b/tasks/0016_971_16971389_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b73f0a9dfb5142bedce6fb65224933b875de685f
--- /dev/null
+++ b/tasks/0016_971_16971389_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 most predictive feature for distinguishing edible from poisonous mushrooms based on value counts 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/0016_971_16971389_qa_1/task.toml b/tasks/0016_971_16971389_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bfde3ed14265c4a73483159d305d2f3aacac6ef1
--- /dev/null
+++ b/tasks/0016_971_16971389_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0016_971_16971389_qa_1"
+description = "What is the most predictive feature for distinguishing edible from poisonous mushrooms based on value counts analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0016/971/16971389.ipynb_qa_1"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "odor"
+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__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "odor"
+QUESTION = "What is the most predictive feature for distinguishing edible from poisonous mushrooms based on value counts 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/0017_291_17291057_qa_1/instruction.md b/tasks/0017_291_17291057_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c61cd26de410395330cf65f77757a5ddfd089302
--- /dev/null
+++ b/tasks/0017_291_17291057_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 feature in the dataset shows the strongest positive correlation with wine quality according to 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/0017_291_17291057_qa_1/task.toml b/tasks/0017_291_17291057_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..01f7123243eb2051082e5cacbaae511fea266046
--- /dev/null
+++ b/tasks/0017_291_17291057_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0017_291_17291057_qa_1"
+description = "Which feature in the dataset shows the strongest positive correlation with wine quality according to the correlation matrix analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0017/291/17291057.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 feature in the dataset shows the strongest positive correlation with wine quality according to 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/0025_564_25564899_qa_4/instruction.md b/tasks/0025_564_25564899_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..223b3709ac9323e3fc196fd0fab6a7fe5725ff98
--- /dev/null
+++ b/tasks/0025_564_25564899_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):
+- gender-classifier-DFE-791531.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which model achieved the highest accuracy when using only the tweet text as input?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0025_564_25564899_qa_4/task.toml b/tasks/0025_564_25564899_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..34b952f99f6227a2bd40836685c9caa18f64902a
--- /dev/null
+++ b/tasks/0025_564_25564899_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0025_564_25564899_qa_4"
+description = "Which model achieved the highest accuracy when using only the tweet text as input?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0025/564/25564899.ipynb_qa_4"
+kaggle_dataset_name = "crowdflower/twitter-user-gender-classification"
+gold_answer = "Logistic Regression"
+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 = "crowdflower__twitter-user-gender-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "crowdflower/twitter-user-gender-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Logistic Regression"
+QUESTION = "Which model achieved the highest accuracy when using only the tweet text as input?"
+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/0027_004_27004450_qa_2/instruction.md b/tasks/0027_004_27004450_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cd6c4557c2ddfed568e355ff37162873a3b9ee40
--- /dev/null
+++ b/tasks/0027_004_27004450_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):
+- games.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which opening for white has the highest win percentage among the top 10 most common openings 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/0027_004_27004450_qa_2/task.toml b/tasks/0027_004_27004450_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2734557595ba7b1f62260acd955770f1e8464b3b
--- /dev/null
+++ b/tasks/0027_004_27004450_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0027_004_27004450_qa_2"
+description = "Which opening for white has the highest win percentage among the top 10 most common openings in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0027/004/27004450.ipynb_qa_2"
+kaggle_dataset_name = "datasnaek/chess"
+gold_answer = "Philiodor Defense #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 = "datasnaek__chess"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "datasnaek/chess"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Scandinavian Defense: Mieses-Kotroc Variation"
+QUESTION = "Which opening for white has the highest win percentage among the top 10 most common openings 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/0027_179_27179583_qa_2/instruction.md b/tasks/0027_179_27179583_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c60e2da153b0808d4d4fc2bbcc0a76260e1d0cf
--- /dev/null
+++ b/tasks/0027_179_27179583_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):
+- 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 comments for Ask HN posts posted at 15:00?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0027_179_27179583_qa_2/task.toml b/tasks/0027_179_27179583_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d1a6d74c41ea21bb10c965f37fafed5581376c1f
--- /dev/null
+++ b/tasks/0027_179_27179583_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0027_179_27179583_qa_2"
+description = "What is the average number of comments for Ask HN posts posted at 15:00?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0027/179/27179583.ipynb_qa_2"
+kaggle_dataset_name = "hacker-news/hacker-news-posts"
+gold_answer = "28.68"
+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 = "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 = "28.68"
+QUESTION = "What is the average number of comments for Ask HN posts posted at 15:00?"
+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/0027_503_27503967_qa_5/instruction.md b/tasks/0027_503_27503967_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae62d21e37a8b7355c07e9b57454de830ced94fb
--- /dev/null
+++ b/tasks/0027_503_27503967_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 was the highest test set accuracy achieved by any of the models evaluated (kNN, Random Forest, Naive Bayes) using their optimized parameters?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0027_503_27503967_qa_5/task.toml b/tasks/0027_503_27503967_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3c9b516ffbdc458819712d60f9feb8d58ee55e0b
--- /dev/null
+++ b/tasks/0027_503_27503967_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0027_503_27503967_qa_5"
+description = "What was the highest test set accuracy achieved by any of the models evaluated (kNN, Random Forest, Naive Bayes) using their optimized parameters?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0027/503/27503967.ipynb_qa_5"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+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 = "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.95"
+QUESTION = "What was the highest test set accuracy achieved by any of the models evaluated (kNN, Random Forest, Naive Bayes) using their optimized parameters?"
+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/0029_184_29184728_qa_1/task.toml b/tasks/0029_184_29184728_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0f62c214a961a9395c72b501ba53c6f54f5e5e40
--- /dev/null
+++ b/tasks/0029_184_29184728_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0029_184_29184728_qa_1"
+description = "Which species of iris has the highest average sepal width according to the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0029/184/29184728.ipynb_qa_1"
+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 of iris has the highest average sepal width 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/0029_630_29630344_qa_4/instruction.md b/tasks/0029_630_29630344_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a163bacbb2b7ec77e8b84051c6336f277818c90d
--- /dev/null
+++ b/tasks/0029_630_29630344_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):
+- Online Retail.xlsx
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many transactions were removed as duplicates from the original 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/0029_630_29630344_qa_4/task.toml b/tasks/0029_630_29630344_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..31bd683fdca2eebcd5fcd9baa1472e903dc6f5ee
--- /dev/null
+++ b/tasks/0029_630_29630344_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0029_630_29630344_qa_4"
+description = "How many transactions were removed as duplicates from the original dataset during preprocessing?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0029/630/29630344.ipynb_qa_4"
+kaggle_dataset_name = "jihyeseo/online-retail-data-set-from-uci-ml-repo"
+gold_answer = "5268"
+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 = "jihyeseo__online-retail-data-set-from-uci-ml-repo"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jihyeseo/online-retail-data-set-from-uci-ml-repo"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5268"
+QUESTION = "How many transactions were removed as duplicates from the original 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/0031_074_31074287_qa_3/instruction.md b/tasks/0031_074_31074287_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f1ca7b634d4c6300a610696018ee8e5f84304e72
--- /dev/null
+++ b/tasks/0031_074_31074287_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 average vintage year of the wines in the dataset after removing entries with missing 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/0031_074_31074287_qa_3/task.toml b/tasks/0031_074_31074287_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4ed2817529dc1e5476fcd8fadb0fd0bdc95eac09
--- /dev/null
+++ b/tasks/0031_074_31074287_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0031_074_31074287_qa_3"
+description = "What is the average vintage year of the wines in the dataset after removing entries with missing years?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/074/31074287.ipynb_qa_3"
+kaggle_dataset_name = "zynicide/wine-reviews"
+gold_answer = "2010.67"
+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 = "zynicide__wine-reviews"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zynicide/wine-reviews"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2010.67"
+QUESTION = "What is the average vintage year of the wines in the dataset after removing entries with missing years?"
+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_954_31954480_qa_3/instruction.md b/tasks/0031_954_31954480_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..ff8e2f089c1c615bde26444de099c7f632eb539a
--- /dev/null
+++ b/tasks/0031_954_31954480_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:
+Which species exhibits the highest average petal width according to the feature averages 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_954_31954480_qa_3/task.toml b/tasks/0031_954_31954480_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3c1aa60864ee7e2afa5633db87efe8bc6a258e99
--- /dev/null
+++ b/tasks/0031_954_31954480_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0031_954_31954480_qa_3"
+description = "Which species exhibits the highest average petal width according to the feature averages analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/954/31954480.ipynb_qa_3"
+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 exhibits the highest average petal width according to the feature averages 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/0033_183_33183014_qa_4/instruction.md b/tasks/0033_183_33183014_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0a1f18ef588386bf23d8ba126c0bb605a3ae0934
--- /dev/null
+++ b/tasks/0033_183_33183014_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 tenure duration for customers with a Two-year contract?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_183_33183014_qa_4/task.toml b/tasks/0033_183_33183014_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2281cc610e96259a5ac8216a77ff43813703e117
--- /dev/null
+++ b/tasks/0033_183_33183014_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0033_183_33183014_qa_4"
+description = "What is the average tenure duration for customers with a Two-year contract?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0033/183/33183014.ipynb_qa_4"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "56.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 = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "56.74"
+QUESTION = "What is the average tenure duration for customers with a Two-year contract?"
+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_417_38417457_qa_1/instruction.md b/tasks/0038_417_38417457_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..acfddb5fa9696d15b9d79b4e58e00c0597e61a53
--- /dev/null
+++ b/tasks/0038_417_38417457_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):
+- kc_house_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 F-value in the SelectKBest feature selection analysis for predicting house prices?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_417_38417457_qa_1/task.toml b/tasks/0038_417_38417457_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ecd54e400268d055689c78cad5f9470b2f780f79
--- /dev/null
+++ b/tasks/0038_417_38417457_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0038_417_38417457_qa_1"
+description = "Which feature has the highest F-value in the SelectKBest feature selection analysis for predicting house prices?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0038/417/38417457.ipynb_qa_1"
+kaggle_dataset_name = "harlfoxem/housesalesprediction"
+gold_answer = "sqft_living"
+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 = "harlfoxem__housesalesprediction"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "sqft_living"
+QUESTION = "Which feature has the highest F-value in the SelectKBest feature selection analysis for predicting house prices?"
+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_815_39815076_qa_3/instruction.md b/tasks/0039_815_39815076_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f68241a57a597f68fa4d6a35f5f040cb47042c2
--- /dev/null
+++ b/tasks/0039_815_39815076_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 algorithm parameter ('auto', 'ball_tree', 'kd_tree', or 'brute') yields the highest model accuracy for the KNN classifier according to the experimental 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/0039_815_39815076_qa_3/task.toml b/tasks/0039_815_39815076_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..691573f0ec0c25ee3e12f43c262e385b893135b3
--- /dev/null
+++ b/tasks/0039_815_39815076_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0039_815_39815076_qa_3"
+description = "Which algorithm parameter ('auto', 'ball_tree', 'kd_tree', or 'brute') yields the highest model accuracy for the KNN classifier according to the experimental results?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0039/815/39815076.ipynb_qa_3"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "auto"
+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 = "auto"
+QUESTION = "Which algorithm parameter ('auto', 'ball_tree', 'kd_tree', or 'brute') yields the highest model accuracy for the KNN classifier according to the experimental 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/0041_323_41323136_qa_3/instruction.md b/tasks/0041_323_41323136_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..391c79c6aabca17eb0e6cc49a0755685007a879d
--- /dev/null
+++ b/tasks/0041_323_41323136_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:
+What is the highest F1 score achieved by any of the naive classification baselines presented in 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/0041_323_41323136_qa_3/task.toml b/tasks/0041_323_41323136_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0c0ff1a4efcfdd01444900659f11abf2026b394e
--- /dev/null
+++ b/tasks/0041_323_41323136_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0041_323_41323136_qa_3"
+description = "What is the highest F1 score achieved by any of the naive classification baselines presented in the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0041/323/41323136.ipynb_qa_3"
+kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data"
+gold_answer = "0.5417"
+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 = "0.5417"
+QUESTION = "What is the highest F1 score achieved by any of the naive classification baselines presented in the 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/0044_153_44153291_qa_4/instruction.md b/tasks/0044_153_44153291_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d287286f292300fe4403188e1c11a34457143344
--- /dev/null
+++ b/tasks/0044_153_44153291_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):
+- tmdb_5000_movies.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean vote average (C value) calculated across all movies 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/0044_153_44153291_qa_4/task.toml b/tasks/0044_153_44153291_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9458f35e4f5f815f85225124b021cb12fb03e042
--- /dev/null
+++ b/tasks/0044_153_44153291_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0044_153_44153291_qa_4"
+description = "What is the mean vote average (C value) calculated across all movies in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0044/153/44153291.ipynb_qa_4"
+kaggle_dataset_name = "tmdb/tmdb-movie-metadata"
+gold_answer = "6.092"
+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 = "tmdb__tmdb-movie-metadata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6.092"
+QUESTION = "What is the mean vote average (C value) calculated across all movies 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/0044_860_44860367_qa_5/instruction.md b/tasks/0044_860_44860367_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..db8c1704e5573352f40aca55229555e3d3316e0a
--- /dev/null
+++ b/tasks/0044_860_44860367_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 publisher holds the largest market share according to the top 10 publishers 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/0044_860_44860367_qa_5/task.toml b/tasks/0044_860_44860367_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5b03fff381c6abaafdba49a0caf0e6bfab59d3e0
--- /dev/null
+++ b/tasks/0044_860_44860367_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0044_860_44860367_qa_5"
+description = "Which publisher holds the largest market share according to the top 10 publishers analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0044/860/44860367.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Nintendo"
+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 = "Nintendo"
+QUESTION = "Which publisher holds the largest market share according to the top 10 publishers 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/0048_101_48101055_qa_3/instruction.md b/tasks/0048_101_48101055_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b04784e568c79720f82c2a7aafc19730214860ea
--- /dev/null
+++ b/tasks/0048_101_48101055_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):
+- data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which weekdays have the lowest average sales compared to other weekdays?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as a comma-separated list of the weekday 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/0048_101_48101055_qa_3/task.toml b/tasks/0048_101_48101055_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..066814e4063ce57aafd1ba15dbe156a5c45d1a63
--- /dev/null
+++ b/tasks/0048_101_48101055_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0048_101_48101055_qa_3"
+description = "Which weekdays have the lowest average sales compared to other weekdays?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0048/101/48101055.ipynb_qa_3"
+kaggle_dataset_name = "carrie1/ecommerce-data"
+gold_answer = "Sunday, Monday"
+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 = "carrie1__ecommerce-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "carrie1/ecommerce-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Sunday, Monday"
+QUESTION = "Which weekdays have the lowest average sales compared to other weekdays?"
+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_008_49008236_qa_5/instruction.md b/tasks/0049_008_49008236_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..439f9843e7a7017147138489a502f90a98a2182a
--- /dev/null
+++ b/tasks/0049_008_49008236_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 data type of the Species column 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/0049_008_49008236_qa_5/task.toml b/tasks/0049_008_49008236_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..75ed906c4c8429e3d9cd7fffb0ff4c44c3544017
--- /dev/null
+++ b/tasks/0049_008_49008236_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0049_008_49008236_qa_5"
+description = "What is the data type of the Species column in the Iris dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0049/008/49008236.ipynb_qa_5"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "object"
+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__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "object"
+QUESTION = "What is the data type of the Species column in the Iris 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/0050_784_50784361_qa_5/instruction.md b/tasks/0050_784_50784361_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..24fb07e8e0915c7f3bcf0713e43e38bddea25f34
--- /dev/null
+++ b/tasks/0050_784_50784361_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):
+- oasis_longitudinal.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean age of participants 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_784_50784361_qa_5/task.toml b/tasks/0050_784_50784361_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f2dfe17f444c9bf1a5b60ac04edeb9a15634b88d
--- /dev/null
+++ b/tasks/0050_784_50784361_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0050_784_50784361_qa_5"
+description = "What is the mean age of participants in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0050/784/50784361.ipynb_qa_5"
+kaggle_dataset_name = "jboysen/mri-and-alzheimers"
+gold_answer = "77.01"
+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 = "jboysen__mri-and-alzheimers"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jboysen/mri-and-alzheimers"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "77.01"
+QUESTION = "What is the mean age of participants 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/0052_980_52980235_qa_2/instruction.md b/tasks/0052_980_52980235_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..51904c41276bdd1a5ee27d7cf93f5d039baad557
--- /dev/null
+++ b/tasks/0052_980_52980235_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):
+- train.csv
+- test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What are the four features selected by Recursive Feature Elimination (RFE) when reducing to 4 features for the Decision Tree 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/0052_980_52980235_qa_2/task.toml b/tasks/0052_980_52980235_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..99fec4d5ec52549bf3485ff8b7dea8b6a37797ab
--- /dev/null
+++ b/tasks/0052_980_52980235_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0052_980_52980235_qa_2"
+description = "What are the four features selected by Recursive Feature Elimination (RFE) when reducing to 4 features for the Decision Tree model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0052/980/52980235.ipynb_qa_2"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "battery_power, px_height, px_width, ram"
+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 = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "battery_power, px_height, px_width, ram"
+QUESTION = "What are the four features selected by Recursive Feature Elimination (RFE) when reducing to 4 features for the Decision Tree model?"
+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/0055_474_55474406_qa_4/instruction.md b/tasks/0055_474_55474406_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..344a482440bae84330337fe1c41ef131e2d03705
--- /dev/null
+++ b/tasks/0055_474_55474406_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:
+How many features were removed from the original dataset when retaining only the top 4 most important features for the reduced 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/0055_474_55474406_qa_4/task.toml b/tasks/0055_474_55474406_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f376b347801554c6617be8046515ca9886bd3912
--- /dev/null
+++ b/tasks/0055_474_55474406_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0055_474_55474406_qa_4"
+description = "How many features were removed from the original dataset when retaining only the top 4 most important features for the reduced model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0055/474/55474406.ipynb_qa_4"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "18"
+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__mushroom-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/mushroom-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "18"
+QUESTION = "How many features were removed from the original dataset when retaining only the top 4 most important features for the reduced 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/0057_778_57778333_qa_3/instruction.md b/tasks/0057_778_57778333_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2c7c7adb8f1b17cd11dcf261499fd544d3114030
--- /dev/null
+++ b/tasks/0057_778_57778333_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):
+- diamonds.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the 75th percentile (third quartile) value of the price distribution 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/0057_778_57778333_qa_3/task.toml b/tasks/0057_778_57778333_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fc367679eec2dc0d86f9270146919d3348766428
--- /dev/null
+++ b/tasks/0057_778_57778333_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0057_778_57778333_qa_3"
+description = "What is the 75th percentile (third quartile) value of the price distribution in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0057/778/57778333.ipynb_qa_3"
+kaggle_dataset_name = "shivam2503/diamonds"
+gold_answer = "5324.25"
+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 = "shivam2503__diamonds"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "shivam2503/diamonds"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5324.25"
+QUESTION = "What is the 75th percentile (third quartile) value of the price distribution 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/0057_915_57915748_qa_2/instruction.md b/tasks/0057_915_57915748_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..73277deceaa39d88c9503b77e1a2a3a26b8498bf
--- /dev/null
+++ b/tasks/0057_915_57915748_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 interquartile range (IQR) for the 'fc' feature in the original 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/0057_915_57915748_qa_2/task.toml b/tasks/0057_915_57915748_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..db2afd2b5ddc43578666562642fd1e1a493e2cc0
--- /dev/null
+++ b/tasks/0057_915_57915748_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0057_915_57915748_qa_2"
+description = "What is the interquartile range (IQR) for the 'fc' feature in the original training dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0057/915/57915748.ipynb_qa_2"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "6.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 = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6.0"
+QUESTION = "What is the interquartile range (IQR) for the 'fc' feature in the original training 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/0059_410_59410836_qa_1/instruction.md b/tasks/0059_410_59410836_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d87f1ef5e9ca6557c4c93aeb6e76bf6ba6b38ed6
--- /dev/null
+++ b/tasks/0059_410_59410836_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):
+- country_profile_variables.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which region has the highest total GDP based on the current prices 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/0059_410_59410836_qa_1/task.toml b/tasks/0059_410_59410836_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1de1078d65975e549ae525f65b3bc086e0e19df5
--- /dev/null
+++ b/tasks/0059_410_59410836_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0059_410_59410836_qa_1"
+description = "Which region has the highest total GDP based on the current prices in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0059/410/59410836.ipynb_qa_1"
+kaggle_dataset_name = "sudalairajkumar/undata-country-profiles"
+gold_answer = "NorthernAmerica"
+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 = "sudalairajkumar__undata-country-profiles"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "sudalairajkumar/undata-country-profiles"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "NorthernAmerica"
+QUESTION = "Which region has the highest total GDP based on the current prices 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/0060_240_60240221_qa_3/instruction.md b/tasks/0060_240_60240221_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bac2b9d8b5b15f5097621fc97fe888c63e931b1f
--- /dev/null
+++ b/tasks/0060_240_60240221_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):
+- directory.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many Starbucks stores in China are operated under the 'Joint Venture' ownership 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/0060_240_60240221_qa_3/task.toml b/tasks/0060_240_60240221_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2e16b511a8f64fdac6cfd5affd819de70c154198
--- /dev/null
+++ b/tasks/0060_240_60240221_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0060_240_60240221_qa_3"
+description = "How many Starbucks stores in China are operated under the 'Joint Venture' ownership type?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0060/240/60240221.ipynb_qa_3"
+kaggle_dataset_name = "starbucks/store-locations"
+gold_answer = "1220"
+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 = "starbucks__store-locations"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "starbucks/store-locations"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1220"
+QUESTION = "How many Starbucks stores in China are operated under the 'Joint Venture' ownership 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/0061_109_61109875_qa_1/instruction.md b/tasks/0061_109_61109875_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d0a84d2e6d9d4b7a184d37db03766e5447284bdd
--- /dev/null
+++ b/tasks/0061_109_61109875_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):
+- movies_metadata.csv
+- links_small.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the minimum number of votes required for a movie to qualify for inclusion in the general top chart based on the 95th percentile calculation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_109_61109875_qa_1/task.toml b/tasks/0061_109_61109875_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f2d8d7d0c8ef053deaf860f253e7366e68b008a7
--- /dev/null
+++ b/tasks/0061_109_61109875_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0061_109_61109875_qa_1"
+description = "What is the minimum number of votes required for a movie to qualify for inclusion in the general top chart based on the 95th percentile calculation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0061/109/61109875.ipynb_qa_1"
+kaggle_dataset_name = "rounakbanik/the-movies-dataset"
+gold_answer = "434"
+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__the-movies-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rounakbanik/the-movies-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "434"
+QUESTION = "What is the minimum number of votes required for a movie to qualify for inclusion in the general top chart based on the 95th percentile calculation?"
+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_164_61164683_qa_1/instruction.md b/tasks/0061_164_61164683_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d144593d461a90213b840de3eefa216e59c6bfd9
--- /dev/null
+++ b/tasks/0061_164_61164683_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):
+- species.csv
+- parks.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum biodiversity count (number of species) recorded in any national park 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/0061_164_61164683_qa_1/task.toml b/tasks/0061_164_61164683_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..12c6879594477056625b9b54d8f20b5d24515205
--- /dev/null
+++ b/tasks/0061_164_61164683_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0061_164_61164683_qa_1"
+description = "What is the maximum biodiversity count (number of species) recorded in any national park in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0061/164/61164683.ipynb_qa_1"
+kaggle_dataset_name = "nationalparkservice/park-biodiversity"
+gold_answer = "6623"
+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 = "nationalparkservice__park-biodiversity"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "nationalparkservice/park-biodiversity"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6623"
+QUESTION = "What is the maximum biodiversity count (number of species) recorded in any national park 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/0065_989_65989824_qa_2/instruction.md b/tasks/0065_989_65989824_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a9bf698f161dae5c4d92326c41ef52d07429fad3
--- /dev/null
+++ b/tasks/0065_989_65989824_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):
+- 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?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_989_65989824_qa_2/task.toml b/tasks/0065_989_65989824_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..abef35289dddf1efc56574b1059ec5f3bf72eeba
--- /dev/null
+++ b/tasks/0065_989_65989824_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0065_989_65989824_qa_2"
+description = "What is the total number of patients in the test set?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0065/989/65989824.ipynb_qa_2"
+kaggle_dataset_name = "crawford/gene-expression"
+gold_answer = "34"
+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 = "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?"
+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/0068_463_68463534_qa_5/instruction.md b/tasks/0068_463_68463534_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a757ed3c9c794d3ee7786271317f186e39c3508c
--- /dev/null
+++ b/tasks/0068_463_68463534_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.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After handling missing values and outliers, what was the mean age of passengers 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/0068_463_68463534_qa_5/task.toml b/tasks/0068_463_68463534_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5ee34a213ff150888f008035bceeedc4bd432609
--- /dev/null
+++ b/tasks/0068_463_68463534_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0068_463_68463534_qa_5"
+description = "After handling missing values and outliers, what was the mean age of passengers in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0068/463/68463534.ipynb_qa_5"
+kaggle_dataset_name = "hesh97/titanicdataset-traincsv"
+gold_answer = "29.0664"
+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 = "hesh97__titanicdataset-traincsv"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "hesh97/titanicdataset-traincsv"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "29.0664"
+QUESTION = "After handling missing values and outliers, what was the mean age of passengers 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/0071_619_71619618_qa_1/instruction.md b/tasks/0071_619_71619618_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..31da5fe6c72b2d8f828b8144d13f7e7440a6a653
--- /dev/null
+++ b/tasks/0071_619_71619618_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:
+What is the proportion of 'bad' quality wines in the dataset after binning into 'bad' and 'good' categories?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_619_71619618_qa_1/task.toml b/tasks/0071_619_71619618_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..40785ad04210e119a5dff8c5dac6d2cba882a5b8
--- /dev/null
+++ b/tasks/0071_619_71619618_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0071_619_71619618_qa_1"
+description = "What is the proportion of 'bad' quality wines in the dataset after binning into 'bad' and 'good' categories?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0071/619/71619618.ipynb_qa_1"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "86.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__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 = "86.4"
+QUESTION = "What is the proportion of 'bad' quality wines in the dataset after binning into 'bad' and 'good' categories?"
+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/0071_909_71909129_qa_1/instruction.md b/tasks/0071_909_71909129_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b9888fbf4170450a61a6065cd0d3ed119685fa46
--- /dev/null
+++ b/tasks/0071_909_71909129_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:
+Which video game genre achieved the highest total global sales across all 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/0071_909_71909129_qa_1/task.toml b/tasks/0071_909_71909129_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1616216fd90e2910b0a3ee5047dbbd09bb81f960
--- /dev/null
+++ b/tasks/0071_909_71909129_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0071_909_71909129_qa_1"
+description = "Which video game genre achieved the highest total global sales across all years in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0071/909/71909129.ipynb_qa_1"
+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 = "Which video game genre achieved the highest total global sales across all years 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/0072_665_72665847_qa_1/instruction.md b/tasks/0072_665_72665847_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a12906d0b4a4b3bac9858b46e9a78fc1658facc6
--- /dev/null
+++ b/tasks/0072_665_72665847_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):
+- bank.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which age group has 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_1/task.toml b/tasks/0072_665_72665847_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8c3ffe70585d3ec36d1c64fb6a7e7247e80aae93
--- /dev/null
+++ b/tasks/0072_665_72665847_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0072_665_72665847_qa_1"
+description = "Which age group has 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_1"
+kaggle_dataset_name = "janiobachmann/bank-marketing-dataset"
+gold_answer = "below 25 and above 60"
+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 = "janiobachmann__bank-marketing-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "below 25 and above 60"
+QUESTION = "Which age group has 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_939_73939724_qa_2/instruction.md b/tasks/0073_939_73939724_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..dcf7d7101ce91e8630af28438bc6a13ebcab28ee
--- /dev/null
+++ b/tasks/0073_939_73939724_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):
+- diamonds.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which color grade is associated with the highest median diamond 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/0073_939_73939724_qa_2/task.toml b/tasks/0073_939_73939724_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4f2253a108e38fb11d50689f23b596a529536b4e
--- /dev/null
+++ b/tasks/0073_939_73939724_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0073_939_73939724_qa_2"
+description = "Which color grade is associated with the highest median diamond price in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0073/939/73939724.ipynb_qa_2"
+kaggle_dataset_name = "shivam2503/diamonds"
+gold_answer = "J"
+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 = "J"
+QUESTION = "Which color grade is associated with the highest median diamond price 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_739_74739274_qa_3/instruction.md b/tasks/0074_739_74739274_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7c6ff91e1d9edb977ebc3d00f9778f2f7f398f1c
--- /dev/null
+++ b/tasks/0074_739_74739274_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):
+- CC GENERAL.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest outlier percentage observed in any feature before 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/0074_739_74739274_qa_3/task.toml b/tasks/0074_739_74739274_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2763b8d9c7e6644a8e5a3a9ecc3e5790b26ca3f4
--- /dev/null
+++ b/tasks/0074_739_74739274_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0074_739_74739274_qa_3"
+description = "What is the highest outlier percentage observed in any feature before preprocessing?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0074/739/74739274.ipynb_qa_3"
+kaggle_dataset_name = "arjunbhasin2013/ccdata"
+gold_answer = "16.68"
+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 = "arjunbhasin2013__ccdata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "arjunbhasin2013/ccdata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "16.68"
+QUESTION = "What is the highest outlier percentage observed in any feature before 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/0074_813_74813463_qa_5/instruction.md b/tasks/0074_813_74813463_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0cbf7807bac6663dcb6ea64d008b0980df095ac8
--- /dev/null
+++ b/tasks/0074_813_74813463_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 Iris-versicolor samples were misclassified as Iris-virginica in the KNN model's validation 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/0074_813_74813463_qa_5/task.toml b/tasks/0074_813_74813463_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..de2582a2a68b29573f683a943b43aecb19b50883
--- /dev/null
+++ b/tasks/0074_813_74813463_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0074_813_74813463_qa_5"
+description = "How many Iris-versicolor samples were misclassified as Iris-virginica in the KNN model's validation predictions?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0074/813/74813463.ipynb_qa_5"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "1"
+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"
+QUESTION = "How many Iris-versicolor samples were misclassified as Iris-virginica in the KNN model's validation predictions?"
+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/0077_133_77133974_qa_4/instruction.md b/tasks/0077_133_77133974_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c73b88610b3c8641025e488293f0e9f8b5f8f07e
--- /dev/null
+++ b/tasks/0077_133_77133974_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):
+- inc_occ_gender.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which job group has the highest average weekly earnings among the analyzed job categories?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_133_77133974_qa_4/task.toml b/tasks/0077_133_77133974_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..318e3822a16814342a3927e605114664bec35c7f
--- /dev/null
+++ b/tasks/0077_133_77133974_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0077_133_77133974_qa_4"
+description = "Which job group has the highest average weekly earnings among the analyzed job categories?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0077/133/77133974.ipynb_qa_4"
+kaggle_dataset_name = "jonavery/incomes-by-career-and-gender"
+gold_answer = "COMPUTATIONAL"
+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 = "jonavery__incomes-by-career-and-gender"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jonavery/incomes-by-career-and-gender"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "COMPUTATIONAL"
+QUESTION = "Which job group has the highest average weekly earnings among the analyzed job categories?"
+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_2/instruction.md b/tasks/0077_902_77902994_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e6f139521875d450f5f7c4dfdf6529b3a3dc6cf1
--- /dev/null
+++ b/tasks/0077_902_77902994_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 percentage of the total_bedrooms column contains missing values 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/0077_902_77902994_qa_2/task.toml b/tasks/0077_902_77902994_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b7d5775dbf063cfd52c28674026fc5b02445ccea
--- /dev/null
+++ b/tasks/0077_902_77902994_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0077_902_77902994_qa_2"
+description = "What percentage of the total_bedrooms column contains missing values before imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0077/902/77902994.ipynb_qa_2"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "1.0029"
+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 = "1.0029"
+QUESTION = "What percentage of the total_bedrooms column contains missing values before imputation?"
+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_564_80564946_qa_4/instruction.md b/tasks/0080_564_80564946_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c1b82811cbf657abd2f34db626560fad30489cd6
--- /dev/null
+++ b/tasks/0080_564_80564946_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):
+- car_evaluation.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the F1 score on the test set for the Decision Tree 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/0080_564_80564946_qa_4/task.toml b/tasks/0080_564_80564946_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ac2382262bb7b56d0b293603dd4182c9ae61fcc5
--- /dev/null
+++ b/tasks/0080_564_80564946_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0080_564_80564946_qa_4"
+description = "What is the F1 score on the test set for the Decision Tree model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0080/564/80564946.ipynb_qa_4"
+kaggle_dataset_name = "elikplim/car-evaluation-data-set"
+gold_answer = "0.92"
+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 = "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 = "0.9754"
+QUESTION = "What is the F1 score on the test set for the Decision Tree model?"
+REWARD_MODE = "numeric"
+ATOL = "0.08"
+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_939_82939452_qa_1/instruction.md b/tasks/0082_939_82939452_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a141d1faf44e30f3c5c0706efc897dfe64fc634e
--- /dev/null
+++ b/tasks/0082_939_82939452_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):
+- bank.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of clients in the dataset subscribed to a term deposit?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_1/task.toml b/tasks/0082_939_82939452_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c62e0b860e91af0bb7b90817749280f5d8d33a0e
--- /dev/null
+++ b/tasks/0082_939_82939452_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0082_939_82939452_qa_1"
+description = "What percentage of clients in the dataset subscribed to a term deposit?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0082/939/82939452.ipynb_qa_1"
+kaggle_dataset_name = "janiobachmann/bank-marketing-dataset"
+gold_answer = "47.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 = "janiobachmann__bank-marketing-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "47.38"
+QUESTION = "What percentage of clients in the dataset subscribed to a term deposit?"
+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_057_86057959_qa_1/instruction.md b/tasks/0086_057_86057959_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..55ff2bc2adc324530a5d1e028aa8ea2df2b2c9a0
--- /dev/null
+++ b/tasks/0086_057_86057959_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):
+- Hitters.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After imputing missing values in the "Salary" variable using the median, what is the median salary value for 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_057_86057959_qa_1/task.toml b/tasks/0086_057_86057959_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c6bb81b2f28c040c781fe4c8f333ea3fe63874de
--- /dev/null
+++ b/tasks/0086_057_86057959_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0086_057_86057959_qa_1"
+description = "After imputing missing values in the \"Salary\" variable using the median, what is the median salary value for the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0086/057/86057959.ipynb_qa_1"
+kaggle_dataset_name = "floser/hitters"
+gold_answer = "425"
+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 = "floser__hitters"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "floser/hitters"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "425"
+QUESTION = "After imputing missing values in the \"Salary\" variable using the median, what is the median salary value for 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_1/instruction.md b/tasks/0088_305_88305132_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f90a322b70f35d3ba799bda0ded30663c44f11f0
--- /dev/null
+++ b/tasks/0088_305_88305132_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_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 movies were removed from the dataset due to missing values in the overview 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/0088_305_88305132_qa_1/task.toml b/tasks/0088_305_88305132_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..196fcdfc0f82833e3234b53a7c20eff96111e9d5
--- /dev/null
+++ b/tasks/0088_305_88305132_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0088_305_88305132_qa_1"
+description = "How many movies were removed from the dataset due to missing values in the overview column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0088/305/88305132.ipynb_qa_1"
+kaggle_dataset_name = "tmdb/tmdb-movie-metadata"
+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 = "tmdb__tmdb-movie-metadata"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "3"
+QUESTION = "How many movies were removed from the dataset due to missing values in the overview 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/0095_236_95236707_qa_2/instruction.md b/tasks/0095_236_95236707_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8a21405c9cb980a1d0ffd2762d073298922529a0
--- /dev/null
+++ b/tasks/0095_236_95236707_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 remain in the final training dataset after removing the PetalLengthCm and Id 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/0095_236_95236707_qa_2/task.toml b/tasks/0095_236_95236707_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6eaaa3f3dda1626f1671fb1d7e0ebfefb5a6990d
--- /dev/null
+++ b/tasks/0095_236_95236707_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0095_236_95236707_qa_2"
+description = "How many features remain in the final training dataset after removing the PetalLengthCm and Id columns?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0095/236/95236707.ipynb_qa_2"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "3"
+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 = "3"
+QUESTION = "How many features remain in the final training dataset after removing the PetalLengthCm and Id 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/0097_234_97234597_qa_3/instruction.md b/tasks/0097_234_97234597_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bfea5a3f4780f32166d703a3c9c77fa5c266503d
--- /dev/null
+++ b/tasks/0097_234_97234597_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 covariance between Sepal Length and Petal Width in the raw (non-standardized) 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/0097_234_97234597_qa_3/task.toml b/tasks/0097_234_97234597_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..325ba42767c605f38be6ad0d195ee4098aaaf156
--- /dev/null
+++ b/tasks/0097_234_97234597_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0097_234_97234597_qa_3"
+description = "What is the covariance between Sepal Length and Petal Width in the raw (non-standardized) iris dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0097/234/97234597.ipynb_qa_3"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "0.5169"
+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.5169"
+QUESTION = "What is the covariance between Sepal Length and Petal Width in the raw (non-standardized) 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/0097_409_97409368_qa_2/instruction.md b/tasks/0097_409_97409368_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f4ca7152eddba92adbaadff8b2e5f278651c362
--- /dev/null
+++ b/tasks/0097_409_97409368_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:
+How many features have a correlation of at least 0.2 with the price_range?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_409_97409368_qa_2/task.toml b/tasks/0097_409_97409368_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..688008d452c9e97d1d490f5c3b611635fa840446
--- /dev/null
+++ b/tasks/0097_409_97409368_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0097_409_97409368_qa_2"
+description = "How many features have a correlation of at least 0.2 with the price_range?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0097/409/97409368.ipynb_qa_2"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "2"
+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 = "2"
+QUESTION = "How many features have a correlation of at least 0.2 with the price_range?"
+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_875_102875624_qa_2/instruction.md b/tasks/0102_875_102875624_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3fa564b3e4d1aeae7f76d6ed7ff3fe890c85fb28
--- /dev/null
+++ b/tasks/0102_875_102875624_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):
+- oasis_longitudinal.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 'SES' 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/0102_875_102875624_qa_2/task.toml b/tasks/0102_875_102875624_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f68da5b95ec2f372aa6cadadb0cec4556b35c308
--- /dev/null
+++ b/tasks/0102_875_102875624_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0102_875_102875624_qa_2"
+description = "How many missing values were present in the 'SES' column before imputation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0102/875/102875624.ipynb_qa_2"
+kaggle_dataset_name = "jboysen/mri-and-alzheimers"
+gold_answer = "19"
+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 = "jboysen__mri-and-alzheimers"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jboysen/mri-and-alzheimers"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "19"
+QUESTION = "How many missing values were present in the 'SES' 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/0106_414_106414508_qa_5/instruction.md b/tasks/0106_414_106414508_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..06b5e490d55bbe5ca21b7ef2c7321a65f138b99b
--- /dev/null
+++ b/tasks/0106_414_106414508_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):
+- car_evaluation.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 'buyPrice' feature after ordinal encoding and MinMax scaling?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_5/task.toml b/tasks/0106_414_106414508_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bc3a5b0dc00a32c3eec5578cfbd7fa8e441e5a1d
--- /dev/null
+++ b/tasks/0106_414_106414508_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0106_414_106414508_qa_5"
+description = "What is the minimum value of the 'buyPrice' feature after ordinal encoding and MinMax scaling?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0106/414/106414508.ipynb_qa_5"
+kaggle_dataset_name = "elikplim/car-evaluation-data-set"
+gold_answer = "0.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 = "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 = "0.0"
+QUESTION = "What is the minimum value of the 'buyPrice' feature after ordinal encoding and MinMax scaling?"
+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_422_109422676_qa_4/instruction.md b/tasks/0109_422_109422676_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..08fa6e7137e3368b13aded7ff45106014246f270
--- /dev/null
+++ b/tasks/0109_422_109422676_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 color category has the highest frequency of diamonds 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_422_109422676_qa_4/task.toml b/tasks/0109_422_109422676_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d47bda879607b8c64939839c514d87e5f0982790
--- /dev/null
+++ b/tasks/0109_422_109422676_qa_4/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0109_422_109422676_qa_4"
+description = "Which color category has the highest frequency of diamonds in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0109/422/109422676.ipynb_qa_4"
+kaggle_dataset_name = "shivam2503/diamonds"
+gold_answer = "G"
+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 = "shivam2503__diamonds"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "shivam2503/diamonds"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "G"
+QUESTION = "Which color category has the highest frequency of diamonds 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/0111_899_111899875_qa_5/instruction.md b/tasks/0111_899_111899875_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f27f1037af50d9d828032eab64293093759a1cad
--- /dev/null
+++ b/tasks/0111_899_111899875_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_-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 percentage for customers with 'Fiber optic' internet service compared to 'DSL' customers?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+: Answer as: <service>, <percentage> pairs, comma-separated, with the service name first and the percentage as a plain number with two decimals followed by a percent sign (e.g., <label1>: 41.89%, <label2>: 18.96%).
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0111_899_111899875_qa_5/task.toml b/tasks/0111_899_111899875_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1fa6a34e855fd00bf3c847cda205bc40a2f0b3a9
--- /dev/null
+++ b/tasks/0111_899_111899875_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0111_899_111899875_qa_5"
+description = "What is the churn rate percentage for customers with 'Fiber optic' internet service compared to 'DSL' customers?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0111/899/111899875.ipynb_qa_5"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "Fiber optic: 41.89%, DSL: 18.96%"
+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 = "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: 41.89%, DSL: 18.96%"
+QUESTION = "What is the churn rate percentage for customers with 'Fiber optic' internet service compared to 'DSL' 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/0112_685_112685295_qa_2/instruction.md b/tasks/0112_685_112685295_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..cabdadede4eeb495d0a3e9a5d867d2499a35956b
--- /dev/null
+++ b/tasks/0112_685_112685295_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:
+How many video games in the dataset have missing Year 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/0112_685_112685295_qa_2/task.toml b/tasks/0112_685_112685295_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1970bfc7a1da716d7f8e29cf553cc7d017f9623f
--- /dev/null
+++ b/tasks/0112_685_112685295_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify/0112_685_112685295_qa_2"
+description = "How many video games in the dataset have missing Year information?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/685/112685295.ipynb_qa_2"
+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 video games in the dataset have missing Year information?"
+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_503_114503160_qa_2/instruction.md b/tasks/0114_503_114503160_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..f79c7ab4bb9ebf00f10f404a04a50a3919fc0fc6
--- /dev/null
+++ b/tasks/0114_503_114503160_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):
+- 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 accuracy rate for predicting non-purchases (Purchased=0) in the initial Support Vector Machine 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/0114_503_114503160_qa_2/task.toml b/tasks/0114_503_114503160_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..217a26792ca8ae0be595822384bf5bab29fc5dff
--- /dev/null
+++ b/tasks/0114_503_114503160_qa_2/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0114_503_114503160_qa_2"
+description = "What is the accuracy rate for predicting non-purchases (Purchased=0) in the initial Support Vector Machine model?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0114/503/114503160.ipynb_qa_2"
+kaggle_dataset_name = "rakeshrau/social-network-ads"
+gold_answer = "94.52"
+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 = "rakeshrau__social-network-ads"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rakeshrau/social-network-ads"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "94.52"
+QUESTION = "What is the accuracy rate for predicting non-purchases (Purchased=0) in the initial Support Vector Machine model?"
+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_582_114582781_qa_5/instruction.md b/tasks/0114_582_114582781_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0b59d607727e9a99def14efc181f7d7f67c3af75
--- /dev/null
+++ b/tasks/0114_582_114582781_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:
+Which feature has the highest coefficient in the trained model, indicating its strongest influence on insurance 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/0114_582_114582781_qa_5/task.toml b/tasks/0114_582_114582781_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..068e970dc5b29afb7e996b201048a87912810336
--- /dev/null
+++ b/tasks/0114_582_114582781_qa_5/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0114_582_114582781_qa_5"
+description = "Which feature has the highest coefficient in the trained model, indicating its strongest influence on insurance charges?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0114/582/114582781.ipynb_qa_5"
+kaggle_dataset_name = "mirichoi0218/insurance"
+gold_answer = "smoker"
+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 = "mirichoi0218__insurance"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mirichoi0218/insurance"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "smoker"
+QUESTION = "Which feature has the highest coefficient in the trained model, indicating its strongest influence on insurance 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/0115_420_115420161_qa_3/instruction.md b/tasks/0115_420_115420161_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0bf69573e762c49c20f8ddb3bbff1d32ff56f6f3
--- /dev/null
+++ b/tasks/0115_420_115420161_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):
+- 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 cumulative global sales, and what is the total value in millions?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer as: <platform>, <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/0115_420_115420161_qa_3/task.toml b/tasks/0115_420_115420161_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..00e79b30e135662c6a6819ad63802015fbc0ecb7
--- /dev/null
+++ b/tasks/0115_420_115420161_qa_3/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "train-verify2/0115_420_115420161_qa_3"
+description = "Which platform has the highest cumulative global sales, and what is the total value in millions?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0115/420/115420161.ipynb_qa_3"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "PS2, 1255.64"
+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 = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "PS2, 1255.64"
+QUESTION = "Which platform has the highest cumulative global sales, and what is the total value in millions?"
+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/0118_014_118014024_qa_4/instruction.md b/tasks/0118_014_118014024_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0659fda38cd2eb19cf589d2a5956115d74f162de
--- /dev/null
+++ b/tasks/0118_014_118014024_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 median BMI value in the Pima Indians Diabetes 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_180_126180239_qa_1/instruction.md b/tasks/0126_180_126180239_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1401c8558f6979e549bdae5e89a0069eff63b55d
--- /dev/null
+++ b/tasks/0126_180_126180239_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:
+Which publisher has the highest total global sales across all 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/0126_180_126180239_qa_1/task.toml b/tasks/0126_180_126180239_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..dfaac0178d587b9820cd78614ebb2cdb5ccb755b
--- /dev/null
+++ b/tasks/0126_180_126180239_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0126_180_126180239_qa_1"
+description = "Which publisher has the highest total global sales across all years in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0126/180/126180239.ipynb_qa_1"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Nintendo"
+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 = "Nintendo"
+QUESTION = "Which publisher has the highest total global sales across all years 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/0126_841_126841685_qa_1/instruction.md b/tasks/0126_841_126841685_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..40d6a367f3c98a7c4362088dbd241b8f4911db85
--- /dev/null
+++ b/tasks/0126_841_126841685_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 skewness value of the Age distribution before imputation of 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/0126_841_126841685_qa_1/task.toml b/tasks/0126_841_126841685_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..084ceb294a4601a27ff5cfef953ed678a2231e7d
--- /dev/null
+++ b/tasks/0126_841_126841685_qa_1/task.toml
@@ -0,0 +1,64 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-train-v1/0126_841_126841685_qa_1"
+description = "What is the skewness value of the Age distribution before imputation of missing values?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0126/841/126841685.ipynb_qa_1"
+kaggle_dataset_name = "abbasit/titanic"
+gold_answer = "0.389"
+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 = "0.389"
+QUESTION = "What is the skewness value of the Age distribution before imputation of missing values?"
+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]