diff --git a/tasks/0000_416_416942_qa_3/instruction.md b/tasks/0000_416_416942_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3534327a1d0de246b35e12123588991eabf6104c
--- /dev/null
+++ b/tasks/0000_416_416942_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):
+- GlobalTemperatures.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the median value of the annual average *LandAverageTemperatureUncertainty*?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0000_416_416942_qa_3/task.toml b/tasks/0000_416_416942_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cac798bc716196b8e4553907b24157aeaa8b23bf
--- /dev/null
+++ b/tasks/0000_416_416942_qa_3/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0000_416_416942_qa_3"
+description = "What is the median value of the annual average *LandAverageTemperatureUncertainty*?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0000/416/416942.ipynb_qa_3"
+kaggle_dataset_name = "berkeleyearth/climate-change-earth-surface-temperature-data"
+gold_answer = "0.4056"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "berkeleyearth__climate-change-earth-surface-temperature-data"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "berkeleyearth/climate-change-earth-surface-temperature-data"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.4056"
+QUESTION = "What is the median value of the annual average *LandAverageTemperatureUncertainty*?"
+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/0000_603_603758_qa_1/instruction.md b/tasks/0000_603_603758_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..200c8f26a450031462e703dba8c75f0dafe8dc98
--- /dev/null
+++ b/tasks/0000_603_603758_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which country has the highest number of athletes in the dataset when considering the top 30 nations by athlete count?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0000_603_603758_qa_1/task.toml b/tasks/0000_603_603758_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..af4e6b8f458a80ec74bf47bb6cab15fcd0510243
--- /dev/null
+++ b/tasks/0000_603_603758_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0000_603_603758_qa_1"
+description = "Which country has the highest number of athletes in the dataset when considering the top 30 nations by athlete count?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0000/603/603758.ipynb_qa_1"
+kaggle_dataset_name = "rio2016/olympic-games"
+gold_answer = "USA"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rio2016__olympic-games"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rio2016/olympic-games"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "USA"
+QUESTION = "Which country has the highest number of athletes in the dataset when considering the top 30 nations by athlete count?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0001_133_1133625_qa_3/instruction.md b/tasks/0001_133_1133625_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e38b4330e2af1d880fd6be9c4dc520332d8f178a
--- /dev/null
+++ b/tasks/0001_133_1133625_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference between the highest and lowest number of votes received by any BJP+ candidate?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_133_1133625_qa_3/task.toml b/tasks/0001_133_1133625_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..098f0d885f2768fe0dbbb0f6b68ff6657cac9b8a
--- /dev/null
+++ b/tasks/0001_133_1133625_qa_3/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0001_133_1133625_qa_3"
+description = "What is the difference between the highest and lowest number of votes received by any BJP+ candidate?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/133/1133625.ipynb_qa_3"
+kaggle_dataset_name = "ankit2106/uttar-pradesh-assembly-elections-2017"
+gold_answer = "256219"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "ankit2106__uttar-pradesh-assembly-elections-2017"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "ankit2106/uttar-pradesh-assembly-elections-2017"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "256219"
+QUESTION = "What is the difference between the highest and lowest number of votes received by any BJP+ candidate?"
+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_264_1264151_qa_3/instruction.md b/tasks/0001_264_1264151_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..bdd1f8a51ee75ac8f1dcebb866ff3afbca971b38
--- /dev/null
+++ b/tasks/0001_264_1264151_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):
+- MissingMigrantsProject.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which region_origin category accounts for the highest total number of deaths in the dataset after consolidating African regions?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0001_264_1264151_qa_3/task.toml b/tasks/0001_264_1264151_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a3e93e3378b27e4278a3b14df33791a629ddfbd4
--- /dev/null
+++ b/tasks/0001_264_1264151_qa_3/task.toml
@@ -0,0 +1,57 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0001_264_1264151_qa_3"
+description = "Which region_origin category accounts for the highest total number of deaths in the dataset after consolidating African regions?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/264/1264151.ipynb_qa_3"
+kaggle_dataset_name = "jmataya/missingmigrants"
+gold_answer = "Africa"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 3
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "jmataya__missingmigrants"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jmataya/missingmigrants"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Africa"
+QUESTION = "Which region_origin category accounts for the highest total number of deaths in the dataset after consolidating African regions?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0001_273_1273208_qa_2/instruction.md b/tasks/0001_273_1273208_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..d9c303a4f3ee69c0fe00d6ef5f19c3092d358497
--- /dev/null
+++ b/tasks/0001_273_1273208_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:
+After undersampling, how many total rows are present in the balanced 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_273_1273208_qa_2/task.toml b/tasks/0001_273_1273208_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0f010f7de2b03d5e81b5945d01ff26459e92c385
--- /dev/null
+++ b/tasks/0001_273_1273208_qa_2/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0001_273_1273208_qa_2"
+description = "After undersampling, how many total rows are present in the balanced dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/273/1273208.ipynb_qa_2"
+kaggle_dataset_name = "mlg-ulb/creditcardfraud"
+gold_answer = "984"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "mlg-ulb__creditcardfraud"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "mlg-ulb/creditcardfraud"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "984"
+QUESTION = "After undersampling, how many total rows are present in the balanced 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_527_1527054_qa_2/instruction.md b/tasks/0001_527_1527054_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b383894489a557c1bdfe0683f934a9c095825b2
--- /dev/null
+++ b/tasks/0001_527_1527054_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:
+In which calendar year did the number of games receiving critic scores first exceed 10, marking the beginning of widespread critic score data collection?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_527_1527054_qa_2/task.toml b/tasks/0001_527_1527054_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..affd96970c7272ce85cd1c65be07a435c1159a6f
--- /dev/null
+++ b/tasks/0001_527_1527054_qa_2/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0001_527_1527054_qa_2"
+description = "In which calendar year did the number of games receiving critic scores first exceed 10, marking the beginning of widespread critic score data collection?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0001/527/1527054.ipynb_qa_2"
+kaggle_dataset_name = "rush4ratio/video-game-sales-with-ratings"
+gold_answer = "1996"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rush4ratio__video-game-sales-with-ratings"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rush4ratio/video-game-sales-with-ratings"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1996"
+QUESTION = "In which calendar year did the number of games receiving critic scores first exceed 10, marking the beginning of widespread critic score data collection?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0002_094_2094844_qa_1/instruction.md b/tasks/0002_094_2094844_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..65df11e5a3621f0b0d971005d51b33d707f97d24
--- /dev/null
+++ b/tasks/0002_094_2094844_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which organization achieved the highest total retweets across all tweets in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0002_094_2094844_qa_1/task.toml b/tasks/0002_094_2094844_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..288c074344f42ac7891bcfe630e33f4a0d2cbf56
--- /dev/null
+++ b/tasks/0002_094_2094844_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0002_094_2094844_qa_1"
+description = "Which organization achieved the highest total retweets across all tweets in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0002/094/2094844.ipynb_qa_1"
+kaggle_dataset_name = "derrickmwiti/24-thousand-tweets-later"
+gold_answer = "ActiveSpaces"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "derrickmwiti__24-thousand-tweets-later"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "derrickmwiti/24-thousand-tweets-later"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "ActiveSpaces"
+QUESTION = "Which organization achieved the highest total retweets across all tweets in the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0002_203_2203940_qa_5/instruction.md b/tasks/0002_203_2203940_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8eddbf9df60438bbd479bd24022874edb0ab3a3a
--- /dev/null
+++ b/tasks/0002_203_2203940_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the total number of samples in the original wine dataset before any data splitting?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0002_203_2203940_qa_5/task.toml b/tasks/0002_203_2203940_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f8228f2943e46d1240e872f19ede2ba368b45212
--- /dev/null
+++ b/tasks/0002_203_2203940_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0002_203_2203940_qa_5"
+description = "What is the total number of samples in the original wine dataset before any data splitting?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0002/203/2203940.ipynb_qa_5"
+kaggle_dataset_name = "brynja/wineuci"
+gold_answer = "178"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "brynja__wineuci"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "brynja/wineuci"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "178"
+QUESTION = "What is the total number of samples in the original wine dataset before any data splitting?"
+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/0013_748_13748223_qa_1/instruction.md b/tasks/0013_748_13748223_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..52e0f02d9594cf2fd262847f2dc738514773f726
--- /dev/null
+++ b/tasks/0013_748_13748223_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which video game has the highest global sales according to the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0013_748_13748223_qa_1/task.toml b/tasks/0013_748_13748223_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c8a1cd48b7158a5b1413198a1f6035a3640f22f4
--- /dev/null
+++ b/tasks/0013_748_13748223_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0013_748_13748223_qa_1"
+description = "Which video game has the highest global sales according to the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0013/748/13748223.ipynb_qa_1"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "Wii Sports"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Wii Sports"
+QUESTION = "Which video game has the highest global sales according to the dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0014_933_14933483_qa_3/instruction.md b/tasks/0014_933_14933483_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8af2c45238a3c7b8a42bf7c3d49e19714f43bc1
--- /dev/null
+++ b/tasks/0014_933_14933483_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 feature exhibits the highest mean value across all samples, and what is that mean?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_933_14933483_qa_3/task.toml b/tasks/0014_933_14933483_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4df58ff2855249a5534a9d2f7cdc0751bad2867e
--- /dev/null
+++ b/tasks/0014_933_14933483_qa_3/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0014_933_14933483_qa_3"
+description = "Which feature exhibits the highest mean value across all samples, and what is that mean?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0014/933/14933483.ipynb_qa_3"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "SepalLengthCm with a mean of 5.843333."
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__iris"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/iris"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "SepalLengthCm with a mean of 5.843333."
+QUESTION = "Which feature exhibits the highest mean value across all samples, and what is that mean?"
+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/0021_030_21030697_qa_5/instruction.md b/tasks/0021_030_21030697_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2a68c910247582e928b67057a4786837cddafb02
--- /dev/null
+++ b/tasks/0021_030_21030697_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):
+- ks-projects-201801.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of projects in the original dataset were either failed or successful (excluding canceled, undefined, live, and suspended states)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0021_030_21030697_qa_5/task.toml b/tasks/0021_030_21030697_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9b6918c125d5c3a4d8b5ea50e17175f53ac80ceb
--- /dev/null
+++ b/tasks/0021_030_21030697_qa_5/task.toml
@@ -0,0 +1,57 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0021_030_21030697_qa_5"
+description = "What percentage of projects in the original dataset were either failed or successful (excluding canceled, undefined, live, and suspended states)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0021/030/21030697.ipynb_qa_5"
+kaggle_dataset_name = "kemical/kickstarter-projects"
+gold_answer = "87.6%"
+reward_mode_initial = "flexible"
+package_tier = 2
+difficulty_level = 2
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kemical__kickstarter-projects"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kemical/kickstarter-projects"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "87.6%"
+QUESTION = "What percentage of projects in the original dataset were either failed or successful (excluding canceled, undefined, live, and suspended states)?"
+REWARD_MODE = "flexible"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0021_643_21643452_qa_5/instruction.md b/tasks/0021_643_21643452_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..590f890b464b797f8f26da49d03c3f1ca2d45cc5
--- /dev/null
+++ b/tasks/0021_643_21643452_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which currency has the highest proportion of successful projects in the dataset based on the heatmap visualization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0021_643_21643452_qa_5/task.toml b/tasks/0021_643_21643452_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..dbb2dd682c50026c148e99e8c6454d2615c4f078
--- /dev/null
+++ b/tasks/0021_643_21643452_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0021_643_21643452_qa_5"
+description = "Which currency has the highest proportion of successful projects in the dataset based on the heatmap visualization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0021/643/21643452.ipynb_qa_5"
+kaggle_dataset_name = "kemical/kickstarter-projects"
+gold_answer = "USD"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kemical__kickstarter-projects"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kemical/kickstarter-projects"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "USD"
+QUESTION = "Which currency has the highest proportion of successful projects in the dataset based on the heatmap visualization?"
+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/0022_169_22169428_qa_5/instruction.md b/tasks/0022_169_22169428_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..a83d7d06ab7f4febec35086fa7f369e15d5aa9d6
--- /dev/null
+++ b/tasks/0022_169_22169428_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the mean absolute error (MAE) of the logistic regression model's predictions for shot make percentage between 22 and 27.3 feet?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0022_169_22169428_qa_5/task.toml b/tasks/0022_169_22169428_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..30c341dd2d61a9b1828a6f4a106a7be19e63121b
--- /dev/null
+++ b/tasks/0022_169_22169428_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0022_169_22169428_qa_5"
+description = "What is the mean absolute error (MAE) of the logistic regression model's predictions for shot make percentage between 22 and 27.3 feet?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0022/169/22169428.ipynb_qa_5"
+kaggle_dataset_name = "dansbecker/nba-shot-logs"
+gold_answer = "0.0199"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "dansbecker__nba-shot-logs"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "dansbecker/nba-shot-logs"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.0199"
+QUESTION = "What is the mean absolute error (MAE) of the logistic regression model's predictions for shot make percentage between 22 and 27.3 feet?"
+REWARD_MODE = "flexible"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0022_193_22193578_qa_5/instruction.md b/tasks/0022_193_22193578_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..74e49a9921728dd8fbb33e28a72221b1648ac06a
--- /dev/null
+++ b/tasks/0022_193_22193578_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):
+- glass.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature in the original dataset (pre-transformation) has the highest kurtosis value, and what is that value?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0022_193_22193578_qa_5/task.toml b/tasks/0022_193_22193578_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b9f29ebb8b7e0af70e7951172ed654cd990818ab
--- /dev/null
+++ b/tasks/0022_193_22193578_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0022_193_22193578_qa_5"
+description = "Which feature in the original dataset (pre-transformation) has the highest kurtosis value, and what is that value?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0022/193/22193578.ipynb_qa_5"
+kaggle_dataset_name = "uciml/glass"
+gold_answer = "K with 54.689699"
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__glass"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/glass"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "K with 54.689699"
+QUESTION = "Which feature in the original dataset (pre-transformation) has the highest kurtosis value, and what is that value?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0023_846_23846255_qa_1/task.toml b/tasks/0023_846_23846255_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1c37fa70bc6ddcdf36107d9aa021cb6f54703171
--- /dev/null
+++ b/tasks/0023_846_23846255_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0023_846_23846255_qa_1"
+description = "What is the absolute difference between the maximum purchase amount and the 75th percentile purchase amount in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0023/846/23846255.ipynb_qa_1"
+kaggle_dataset_name = "sdolezel/black-friday"
+gold_answer = "11907.00"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "sdolezel__black-friday"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "sdolezel/black-friday"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "11907.00"
+QUESTION = "What is the absolute difference between the maximum purchase amount and the 75th percentile purchase amount in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0024_275_24275657_qa_5/instruction.md b/tasks/0024_275_24275657_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..67fd3c1d5b8b2b76725483edb18f1cd4723de005
--- /dev/null
+++ b/tasks/0024_275_24275657_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of variance is explained by the second principal component in the PCA analysis of 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/0024_275_24275657_qa_5/task.toml b/tasks/0024_275_24275657_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b9d5ba9a86ecaba225a3ae70e93f21a2b21b513f
--- /dev/null
+++ b/tasks/0024_275_24275657_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0024_275_24275657_qa_5"
+description = "What percentage of variance is explained by the second principal component in the PCA analysis of the Iris dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0024/275/24275657.ipynb_qa_5"
+kaggle_dataset_name = "uciml/iris"
+gold_answer = "23.03"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.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 = "23.03"
+QUESTION = "What percentage of variance is explained by the second principal component in the PCA analysis of the Iris dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0026_826_26826730_qa_1/instruction.md b/tasks/0026_826_26826730_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ddc46c6e72df0736f151f5faa77d7745b06cc0c
--- /dev/null
+++ b/tasks/0026_826_26826730_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- WA_Fn-UseC_-HR-Employee-Attrition.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature has the highest chi-square score for predicting employee attrition according to the feature selection 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/0026_826_26826730_qa_1/task.toml b/tasks/0026_826_26826730_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7fd24434ce1ea31038b06e1dfdbe7ff515d760a6
--- /dev/null
+++ b/tasks/0026_826_26826730_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0026_826_26826730_qa_1"
+description = "Which feature has the highest chi-square score for predicting employee attrition according to the feature selection analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0026/826/26826730.ipynb_qa_1"
+kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+gold_answer = "MonthlyIncome"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "MonthlyIncome"
+QUESTION = "Which feature has the highest chi-square score for predicting employee attrition according to the feature selection 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/0031_829_31829521_qa_1/instruction.md b/tasks/0031_829_31829521_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c6fb2fb517be16358c1b474de7b1d5584d9bd899
--- /dev/null
+++ b/tasks/0031_829_31829521_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- pokemon.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the highest Attack stat among first generation legendary Pokémon?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0031_829_31829521_qa_1/task.toml b/tasks/0031_829_31829521_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..395784bb53d58a2f8144d80927048a98b2f5b707
--- /dev/null
+++ b/tasks/0031_829_31829521_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0031_829_31829521_qa_1"
+description = "What is the highest Attack stat among first generation legendary Pokémon?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0031/829/31829521.ipynb_qa_1"
+kaggle_dataset_name = "terminus7/pokemon-challenge"
+gold_answer = "190"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "terminus7__pokemon-challenge"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "190"
+QUESTION = "What is the highest Attack stat among first generation legendary Pokémon?"
+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/0032_442_32442771_qa_3/instruction.md b/tasks/0032_442_32442771_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4034b2c5962b072b931536fe1758d0bc4021ad82
--- /dev/null
+++ b/tasks/0032_442_32442771_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many chocolate bars in the dataset use blended bean types in their production?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0032_442_32442771_qa_3/task.toml b/tasks/0032_442_32442771_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2c84dc766ba0f56b03ced818272428a733b888d8
--- /dev/null
+++ b/tasks/0032_442_32442771_qa_3/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0032_442_32442771_qa_3"
+description = "How many chocolate bars in the dataset use blended bean types in their production?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0032/442/32442771.ipynb_qa_3"
+kaggle_dataset_name = "rtatman/chocolate-bar-ratings"
+gold_answer = "103"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rtatman__chocolate-bar-ratings"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rtatman/chocolate-bar-ratings"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "103"
+QUESTION = "How many chocolate bars in the dataset use blended bean types in their production?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0034_380_34380054_qa_2/instruction.md b/tasks/0034_380_34380054_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..8d3f628afa97a11fbffbc6f652fd965fe1307cb0
--- /dev/null
+++ b/tasks/0034_380_34380054_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the coefficient of the run difference (RD) in the linear regression model predicting wins from RD?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0034_380_34380054_qa_2/task.toml b/tasks/0034_380_34380054_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..53aef2c19b5572d26509c554700b5b8dd259f659
--- /dev/null
+++ b/tasks/0034_380_34380054_qa_2/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0034_380_34380054_qa_2"
+description = "What is the coefficient of the run difference (RD) in the linear regression model predicting wins from RD?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0034/380/34380054.ipynb_qa_2"
+kaggle_dataset_name = "wduckett/moneyball-mlb-stats-19622012"
+gold_answer = "0.1058"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "wduckett__moneyball-mlb-stats-19622012"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "wduckett/moneyball-mlb-stats-19622012"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.1058"
+QUESTION = "What is the coefficient of the run difference (RD) in the linear regression model predicting wins from RD?"
+REWARD_MODE = "flexible"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0040_627_40627093_qa_1/task.toml b/tasks/0040_627_40627093_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6bc8d969b7593793659228ec71a575dc374276b7
--- /dev/null
+++ b/tasks/0040_627_40627093_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0040_627_40627093_qa_1"
+description = "Which feature shows the strongest positive correlation with the diabetes outcome (Outcome=1) in the preprocessed dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0040/627/40627093.ipynb_qa_1"
+kaggle_dataset_name = "saurabh00007/diabetescsv"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "saurabh00007__diabetescsv"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "saurabh00007/diabetescsv"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "Which feature shows the strongest positive correlation with the diabetes outcome (Outcome=1) in the preprocessed dataset?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0043_043_43043497_qa_2/instruction.md b/tasks/0043_043_43043497_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa1763f31f9cdec99bfc3b0e09f9a79849913a5f
--- /dev/null
+++ b/tasks/0043_043_43043497_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- diabetes.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which feature exhibits the highest correlation with the diabetes outcome according to the dataset's correlation matrix?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0043_043_43043497_qa_2/task.toml b/tasks/0043_043_43043497_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..29b10b30c62ec6f2e0ace934e925b156d16a53ff
--- /dev/null
+++ b/tasks/0043_043_43043497_qa_2/task.toml
@@ -0,0 +1,57 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0043_043_43043497_qa_2"
+description = "Which feature exhibits the highest correlation with the diabetes outcome according to the dataset's correlation matrix?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0043/043/43043497.ipynb_qa_2"
+kaggle_dataset_name = "uciml/pima-indians-diabetes-database"
+gold_answer = "Glucose"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 2
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__pima-indians-diabetes-database"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "Glucose"
+QUESTION = "Which feature exhibits the highest correlation with the diabetes outcome according to the dataset's correlation matrix?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0045_466_45466628_qa_3/instruction.md b/tasks/0045_466_45466628_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6ebda71f7b5573ced6dcb5cfdc9c1c01a3fd9562
--- /dev/null
+++ b/tasks/0045_466_45466628_qa_3/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which chemical component exhibits the highest standard deviation 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/0045_466_45466628_qa_3/task.toml b/tasks/0045_466_45466628_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ddaf3db505528405464b3ad8699c3e2e13170afb
--- /dev/null
+++ b/tasks/0045_466_45466628_qa_3/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0045_466_45466628_qa_3"
+description = "Which chemical component exhibits the highest standard deviation in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0045/466/45466628.ipynb_qa_3"
+kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009"
+gold_answer = "total sulfur dioxide"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "total sulfur dioxide"
+QUESTION = "Which chemical component exhibits the highest standard deviation 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/0046_875_46875284_qa_1/instruction.md b/tasks/0046_875_46875284_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..575d49075b2477e6ec43afe99887c2671ebb5560
--- /dev/null
+++ b/tasks/0046_875_46875284_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many Pokémon have both Defense greater than 200 and Attack greater than 100?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0046_875_46875284_qa_1/task.toml b/tasks/0046_875_46875284_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e5daee6bfea51ea07d4f43fd01b22698da33965a
--- /dev/null
+++ b/tasks/0046_875_46875284_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0046_875_46875284_qa_1"
+description = "How many Pokémon have both Defense greater than 200 and Attack greater than 100?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0046/875/46875284.ipynb_qa_1"
+kaggle_dataset_name = "terminus7/pokemon-challenge"
+gold_answer = "2"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "terminus7__pokemon-challenge"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2"
+QUESTION = "How many Pokémon have both Defense greater than 200 and Attack greater than 100?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0048_093_48093392_qa_5/instruction.md b/tasks/0048_093_48093392_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c4fed18b821c4b7d21959dce69efc8892f21362b
--- /dev/null
+++ b/tasks/0048_093_48093392_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):
+- german_credit_data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the accuracy score of the Logistic Regression model after hyperparameter tuning using cross-validation?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_093_48093392_qa_5/task.toml b/tasks/0048_093_48093392_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b6f7253bc0b806d2b95f3948895ed94a3fd478ca
--- /dev/null
+++ b/tasks/0048_093_48093392_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0048_093_48093392_qa_5"
+description = "What was the accuracy score of the Logistic Regression model after hyperparameter tuning using cross-validation?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0048/093/48093392.ipynb_qa_5"
+kaggle_dataset_name = "kabure/german-credit-data-with-risk"
+gold_answer = "0.71"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kabure__german-credit-data-with-risk"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kabure/german-credit-data-with-risk"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.71"
+QUESTION = "What was the accuracy score of the Logistic Regression model after hyperparameter tuning using cross-validation?"
+REWARD_MODE = "flexible"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0050_704_50704224_qa_1/instruction.md b/tasks/0050_704_50704224_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..51691bded147fccfa75bc0196dc50f6807749232
--- /dev/null
+++ b/tasks/0050_704_50704224_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of rows with missing 'stalk-root' values belong to the poisonous mushroom class (class 'p')?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_704_50704224_qa_1/task.toml b/tasks/0050_704_50704224_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..db852e5c7ea16b5d129b69ce5dfefd8e2eee16f6
--- /dev/null
+++ b/tasks/0050_704_50704224_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0050_704_50704224_qa_1"
+description = "What percentage of rows with missing 'stalk-root' values belong to the poisonous mushroom class (class 'p')?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0050/704/50704224.ipynb_qa_1"
+kaggle_dataset_name = "uciml/mushroom-classification"
+gold_answer = "71"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.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 = "71"
+QUESTION = "What percentage of rows with missing 'stalk-root' values belong to the poisonous mushroom class (class 'p')?"
+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/0050_797_50797720_qa_5/instruction.md b/tasks/0050_797_50797720_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..08df8d4fe4183f66c5a63773efa62d72517ee935
--- /dev/null
+++ b/tasks/0050_797_50797720_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of respondents believe that discussing a mental health issue with their employer would have negative consequences?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_797_50797720_qa_5/task.toml b/tasks/0050_797_50797720_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7272e86de362ad9685bc97bdd57dc5c6ed294d20
--- /dev/null
+++ b/tasks/0050_797_50797720_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0050_797_50797720_qa_5"
+description = "What percentage of respondents believe that discussing a mental health issue with their employer would have negative consequences?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0050/797/50797720.ipynb_qa_5"
+kaggle_dataset_name = "osmi/mental-health-in-tech-survey"
+gold_answer = "22.98"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "osmi__mental-health-in-tech-survey"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "osmi/mental-health-in-tech-survey"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "22.98"
+QUESTION = "What percentage of respondents believe that discussing a mental health issue with their employer would have negative consequences?"
+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/0051_637_51637337_qa_1/instruction.md b/tasks/0051_637_51637337_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..29097b0fa3c286a61e1c35056b785f54cf235399
--- /dev/null
+++ b/tasks/0051_637_51637337_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+After balancing the dataset by sampling non-fraudulent transactions, how many non-fraudulent transactions are included 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/0051_637_51637337_qa_1/task.toml b/tasks/0051_637_51637337_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..121115b5ca53ebfbdcb4f1099e4846625ef1eb82
--- /dev/null
+++ b/tasks/0051_637_51637337_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0051_637_51637337_qa_1"
+description = "After balancing the dataset by sampling non-fraudulent transactions, how many non-fraudulent transactions are included in the analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0051/637/51637337.ipynb_qa_1"
+kaggle_dataset_name = "jacklizhi/creditcard"
+gold_answer = "492"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "jacklizhi__creditcard"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "jacklizhi/creditcard"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "492"
+QUESTION = "After balancing the dataset by sampling non-fraudulent transactions, how many non-fraudulent transactions are included in the analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0053_295_53295093_qa_1/instruction.md b/tasks/0053_295_53295093_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1aa4e696921339b9ee47672e05210443ba44a3ba
--- /dev/null
+++ b/tasks/0053_295_53295093_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):
+- jena_climate_2009_2016.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the root mean square error (RMSE) of the naive time series forecasting model in normalized units?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0053_295_53295093_qa_1/task.toml b/tasks/0053_295_53295093_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bb3e842f6dead875c199816e9c73f9900e14c145
--- /dev/null
+++ b/tasks/0053_295_53295093_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0053_295_53295093_qa_1"
+description = "What is the root mean square error (RMSE) of the naive time series forecasting model in normalized units?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0053/295/53295093.ipynb_qa_1"
+kaggle_dataset_name = "pankrzysiu/weather-archive-jena"
+gold_answer = "0.03"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "pankrzysiu__weather-archive-jena"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "pankrzysiu/weather-archive-jena"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.03"
+QUESTION = "What is the root mean square error (RMSE) of the naive time series forecasting model in normalized units?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0054_315_54315694_qa_4/instruction.md b/tasks/0054_315_54315694_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1a21a20cf8718ceccad4ff7907907cb7a992866d
--- /dev/null
+++ b/tasks/0054_315_54315694_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:
+After data cleaning and dropping the 'quantity_footnotes' column, how many columns remain in the final dataset used for analysis?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0054_315_54315694_qa_4/task.toml b/tasks/0054_315_54315694_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ea2c05ea7703d3e62dcd2ac746159d0fe172e860
--- /dev/null
+++ b/tasks/0054_315_54315694_qa_4/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0054_315_54315694_qa_4"
+description = "After data cleaning and dropping the 'quantity_footnotes' column, how many columns remain in the final dataset used for analysis?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0054/315/54315694.ipynb_qa_4"
+kaggle_dataset_name = "unitednations/international-energy-statistics"
+gold_answer = "6"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "unitednations__international-energy-statistics"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "unitednations/international-energy-statistics"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6"
+QUESTION = "After data cleaning and dropping the 'quantity_footnotes' column, how many columns remain in the final dataset used for analysis?"
+REWARD_MODE = "numeric"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0058_378_58378917_qa_4/instruction.md b/tasks/0058_378_58378917_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..13e8af59b9d9062b83c42d92e2933ad18d601009
--- /dev/null
+++ b/tasks/0058_378_58378917_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:
+Which state has the highest number of reported police shootings in the dataset according to the frequency analysis of the "state" field?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0058_378_58378917_qa_4/task.toml b/tasks/0058_378_58378917_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..236fe75c78368b1364718f447fe54a1ec5039fb0
--- /dev/null
+++ b/tasks/0058_378_58378917_qa_4/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0058_378_58378917_qa_4"
+description = "Which state has the highest number of reported police shootings in the dataset according to the frequency analysis of the \"state\" field?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0058/378/58378917.ipynb_qa_4"
+kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us"
+gold_answer = "CA"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kwullum__fatal-police-shootings-in-the-us"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "CA"
+QUESTION = "Which state has the highest number of reported police shootings in the dataset according to the frequency analysis of the \"state\" field?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0065_794_65794937_qa_3/instruction.md b/tasks/0065_794_65794937_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..3b3e5db8c295079abd6d3b99fe3423810fe76cd3
--- /dev/null
+++ b/tasks/0065_794_65794937_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):
+- Tesla.csv - Tesla.csv.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the maximum normalized value for the Close price after Min-Max 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/0065_794_65794937_qa_3/task.toml b/tasks/0065_794_65794937_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6f91ea73d691cd3c5498c5fe154116439e1cfac8
--- /dev/null
+++ b/tasks/0065_794_65794937_qa_3/task.toml
@@ -0,0 +1,57 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0065_794_65794937_qa_3"
+description = "What is the maximum normalized value for the Close price after Min-Max scaling?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0065/794/65794937.ipynb_qa_3"
+kaggle_dataset_name = "rpaguirre/tesla-stock-price"
+gold_answer = "0.9091918"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 2
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "rpaguirre__tesla-stock-price"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "rpaguirre/tesla-stock-price"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "1.0"
+QUESTION = "What is the maximum normalized value for the Close price after Min-Max scaling?"
+REWARD_MODE = "numeric"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0066_372_66372058_qa_2/instruction.md b/tasks/0066_372_66372058_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..940a2aa78fd7e278148c4f9245b4ccbe5b9ed7f7
--- /dev/null
+++ b/tasks/0066_372_66372058_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the percentage of loans with a "Short Term" duration compared to "Long Term" loans 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/0066_372_66372058_qa_2/task.toml b/tasks/0066_372_66372058_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f484d28c87fb98788e463b5f300e0039b734c0b7
--- /dev/null
+++ b/tasks/0066_372_66372058_qa_2/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0066_372_66372058_qa_2"
+description = "What is the percentage of loans with a \"Short Term\" duration compared to \"Long Term\" loans in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0066/372/66372058.ipynb_qa_2"
+kaggle_dataset_name = "zaurbegiev/my-dataset"
+gold_answer = "72.208"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "zaurbegiev__my-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "zaurbegiev/my-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "72.208"
+QUESTION = "What is the percentage of loans with a \"Short Term\" duration compared to \"Long Term\" loans 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/0072_789_72789077_qa_4/instruction.md b/tasks/0072_789_72789077_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..843b5f7cdcc340990229b247343835bfa001723a
--- /dev/null
+++ b/tasks/0072_789_72789077_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average area population across all samples in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0072_789_72789077_qa_4/task.toml b/tasks/0072_789_72789077_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..86d472155d7dd50407e4cfb5d2fef94fbe0aaa7c
--- /dev/null
+++ b/tasks/0072_789_72789077_qa_4/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0072_789_72789077_qa_4"
+description = "What is the average area population across all samples in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0072/789/72789077.ipynb_qa_4"
+kaggle_dataset_name = "vedavyasv/usa-housing"
+gold_answer = "36163.516"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "vedavyasv__usa-housing"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "vedavyasv/usa-housing"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "36163.516"
+QUESTION = "What is the average area population across all samples in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.001"
+RTOL = "0.005"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0077_684_77684454_qa_2/instruction.md b/tasks/0077_684_77684454_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..281ebe159ec84f20cdae9f8433005425f71a6a58
--- /dev/null
+++ b/tasks/0077_684_77684454_qa_2/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the percentage of Nobel Prize laureates classified as 'Senior' in the Age_Group feature (age 65+)?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_684_77684454_qa_2/task.toml b/tasks/0077_684_77684454_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8402bcd9b1e204170683ee8c721a1c127751df4e
--- /dev/null
+++ b/tasks/0077_684_77684454_qa_2/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0077_684_77684454_qa_2"
+description = "What is the percentage of Nobel Prize laureates classified as 'Senior' in the Age_Group feature (age 65+)?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0077/684/77684454.ipynb_qa_2"
+kaggle_dataset_name = "nobelfoundation/nobel-laureates"
+gold_answer = "34.22"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "nobelfoundation__nobel-laureates"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "nobelfoundation/nobel-laureates"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "34.22"
+QUESTION = "What is the percentage of Nobel Prize laureates classified as 'Senior' in the Age_Group feature (age 65+)?"
+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/0078_779_78779265_qa_1/instruction.md b/tasks/0078_779_78779265_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..acb79e4eb01eaa79247223414611130ba3fb71e9
--- /dev/null
+++ b/tasks/0078_779_78779265_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What was the number of rows remaining in the dataset after applying Z-score to remove price outliers?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0078_779_78779265_qa_1/task.toml b/tasks/0078_779_78779265_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..566d8b009c836d0b67a9d7565c8889a21fe10c07
--- /dev/null
+++ b/tasks/0078_779_78779265_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0078_779_78779265_qa_1"
+description = "What was the number of rows remaining in the dataset after applying Z-score to remove price outliers?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0078/779/78779265.ipynb_qa_1"
+kaggle_dataset_name = "harlfoxem/housesalesprediction"
+gold_answer = "21207"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.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 = "21207"
+QUESTION = "What was the number of rows remaining in the dataset after applying Z-score to remove price outliers?"
+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/0079_455_79455690_qa_1/instruction.md b/tasks/0079_455_79455690_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..110b47f0fe281980fdc99251c6afc83439d867fa
--- /dev/null
+++ b/tasks/0079_455_79455690_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many products are categorized as "Low Fat" after correcting the inconsistencies in the Item_Fat_Content 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/0079_455_79455690_qa_1/task.toml b/tasks/0079_455_79455690_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..db54746cad6e3333a5c7a5ed51dc255df3deb02f
--- /dev/null
+++ b/tasks/0079_455_79455690_qa_1/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0079_455_79455690_qa_1"
+description = "How many products are categorized as \"Low Fat\" after correcting the inconsistencies in the Item_Fat_Content column?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0079/455/79455690.ipynb_qa_1"
+kaggle_dataset_name = "devashish0507/big-mart-sales-prediction"
+gold_answer = "5517"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "devashish0507__big-mart-sales-prediction"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "devashish0507/big-mart-sales-prediction"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "5517"
+QUESTION = "How many products are categorized as \"Low Fat\" after correcting the inconsistencies in the Item_Fat_Content 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/0089_787_89787610_qa_4/instruction.md b/tasks/0089_787_89787610_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fd2f73fa5b4ff61e587bd15c970f5da652c03b68
--- /dev/null
+++ b/tasks/0089_787_89787610_qa_4/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing_train.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+How many rows were removed from the dataset after identifying outliers in GrLivArea and SalePrice?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0089_787_89787610_qa_4/task.toml b/tasks/0089_787_89787610_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..802ccbe5b6475bb125401376e922b4522b76ff27
--- /dev/null
+++ b/tasks/0089_787_89787610_qa_4/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0089_787_89787610_qa_4"
+description = "How many rows were removed from the dataset after identifying outliers in GrLivArea and SalePrice?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0089/787/89787610.ipynb_qa_4"
+kaggle_dataset_name = "gpandi007/usa-housing-dataset"
+gold_answer = "2 rows"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gpandi007__usa-housing-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gpandi007/usa-housing-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2 rows"
+QUESTION = "How many rows were removed from the dataset after identifying outliers in GrLivArea and SalePrice?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0092_354_92354139_qa_3/instruction.md b/tasks/0092_354_92354139_qa_3/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4624ed4c905732bff5080ec40bdf049e246019f7
--- /dev/null
+++ b/tasks/0092_354_92354139_qa_3/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- deliveries.csv
+- matches.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which season recorded the highest total runs scored from sixes, and what was the total contribution to runs from sixes during that season?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0092_354_92354139_qa_3/task.toml b/tasks/0092_354_92354139_qa_3/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..50de09e47d9700157314b3eeef76d323d129fc32
--- /dev/null
+++ b/tasks/0092_354_92354139_qa_3/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0092_354_92354139_qa_3"
+description = "Which season recorded the highest total runs scored from sixes, and what was the total contribution to runs from sixes during that season?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0092/354/92354139.ipynb_qa_3"
+kaggle_dataset_name = "manasgarg/ipl"
+gold_answer = "2019 season with 1,245 runs from sixes"
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "manasgarg__ipl"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "manasgarg/ipl"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "2012 season with 4398 runs from sixes"
+QUESTION = "Which season recorded the highest total runs scored from sixes, and what was the total contribution to runs from sixes during that season?"
+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/0095_843_95843375_qa_5/instruction.md b/tasks/0095_843_95843375_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..adcd521f52a85fa53723cf201b632e7a2e7c1282
--- /dev/null
+++ b/tasks/0095_843_95843375_qa_5/instruction.md
@@ -0,0 +1,20 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- Ball_by_Ball.csv
+- Match.csv
+- Player.csv
+- Player_Match.csv
+- Season.csv
+- Team.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of players in the dataset are right-handed batters?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_843_95843375_qa_5/task.toml b/tasks/0095_843_95843375_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7607604a035ab77ed16e148c987b37ebb0ba6212
--- /dev/null
+++ b/tasks/0095_843_95843375_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0095_843_95843375_qa_5"
+description = "What percentage of players in the dataset are right-handed batters?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0095/843/95843375.ipynb_qa_5"
+kaggle_dataset_name = "harsha547/indian-premier-league-csv-dataset"
+gold_answer = "93%"
+reward_mode_initial = "exact_short"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "harsha547__indian-premier-league-csv-dataset"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "harsha547/indian-premier-league-csv-dataset"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "73.25%"
+QUESTION = "What percentage of players in the dataset are right-handed batters?"
+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/0102_826_102826628_qa_5/instruction.md b/tasks/0102_826_102826628_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..4bb1beee816feb760736b5f159e35f8593d5ae86
--- /dev/null
+++ b/tasks/0102_826_102826628_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):
+- Life Expectancy Data.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between adult mortality rates and life expectancy in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0102_826_102826628_qa_5/task.toml b/tasks/0102_826_102826628_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cc227e165eb1137e1cbb4931f43e0379f664d801
--- /dev/null
+++ b/tasks/0102_826_102826628_qa_5/task.toml
@@ -0,0 +1,57 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0102_826_102826628_qa_5"
+description = "What is the correlation coefficient between adult mortality rates and life expectancy in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0102/826/102826628.ipynb_qa_5"
+kaggle_dataset_name = "kumarajarshi/life-expectancy-who"
+gold_answer = "-0.7"
+reward_mode_initial = "numeric"
+package_tier = 1
+difficulty_level = 1
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "kumarajarshi__life-expectancy-who"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "-0.7"
+QUESTION = "What is the correlation coefficient between adult mortality rates and life expectancy in the dataset?"
+REWARD_MODE = "numeric"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0106_109_106109470_qa_2/instruction.md b/tasks/0106_109_106109470_qa_2/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..96e6c6452a9134e0990f4d011fe846287dad0b09
--- /dev/null
+++ b/tasks/0106_109_106109470_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:
+What is the percentage decrease in the standard deviation of the 'carat' feature after outlier removal compared to the original dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0106_109_106109470_qa_2/task.toml b/tasks/0106_109_106109470_qa_2/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d856a8ce52df3f931a141637a6dd906b8ac5c170
--- /dev/null
+++ b/tasks/0106_109_106109470_qa_2/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0106_109_106109470_qa_2"
+description = "What is the percentage decrease in the standard deviation of the 'carat' feature after outlier removal compared to the original dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0106/109/106109470.ipynb_qa_2"
+kaggle_dataset_name = "shivam2503/diamonds"
+gold_answer = "17.1%"
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.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 = "15.17%"
+QUESTION = "What is the percentage decrease in the standard deviation of the 'carat' feature after outlier removal compared to the original dataset?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0110_147_110147085_qa_1/instruction.md b/tasks/0110_147_110147085_qa_1/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..7789fd50b177fd84c7d074bcdf7051e59e9a4f85
--- /dev/null
+++ b/tasks/0110_147_110147085_qa_1/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- housing.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+Which ocean proximity category contains the highest number of districts, and how many districts are in that category?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0110_147_110147085_qa_1/task.toml b/tasks/0110_147_110147085_qa_1/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c9f9899d4d3b1c8e0ac2f0925287dd06e9e69719
--- /dev/null
+++ b/tasks/0110_147_110147085_qa_1/task.toml
@@ -0,0 +1,57 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0110_147_110147085_qa_1"
+description = "Which ocean proximity category contains the highest number of districts, and how many districts are in that category?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0110/147/110147085.ipynb_qa_1"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "<1H OCEAN with 9136 districts"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 1
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "camnugent__california-housing-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "camnugent/california-housing-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "<1H OCEAN with 9136 districts"
+QUESTION = "Which ocean proximity category contains the highest number of districts, and how many districts are in that category?"
+REWARD_MODE = "exact_short"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0112_857_112857611_qa_5/instruction.md b/tasks/0112_857_112857611_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..02308159c20f283bd9d7e27b3a0d12a2aa7968c9
--- /dev/null
+++ b/tasks/0112_857_112857611_qa_5/instruction.md
@@ -0,0 +1,16 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- train.csv
+- test.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the correlation coefficient between the battery_power feature and price_range after all feature engineering steps?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0112_857_112857611_qa_5/task.toml b/tasks/0112_857_112857611_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..868227749212eefa74bde78816cc1fc7314c790f
--- /dev/null
+++ b/tasks/0112_857_112857611_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0112_857_112857611_qa_5"
+description = "What is the correlation coefficient between the battery_power feature and price_range after all feature engineering steps?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0112/857/112857611.ipynb_qa_5"
+kaggle_dataset_name = "iabhishekofficial/mobile-price-classification"
+gold_answer = "0.200723"
+reward_mode_initial = "numeric"
+package_tier = 2
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "0.200723"
+QUESTION = "What is the correlation coefficient between the battery_power feature and price_range after all feature engineering steps?"
+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/0115_676_115676411_qa_5/instruction.md b/tasks/0115_676_115676411_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..60f6c51d6d55808cc20ee5bf3b2a05ff275f5da4
--- /dev/null
+++ b/tasks/0115_676_115676411_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What percentage of total global sales in the dataset came from the North American (NA) region?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value 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_676_115676411_qa_5/task.toml b/tasks/0115_676_115676411_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..71f826018e79211b110216ca47cf31d71ab3b40c
--- /dev/null
+++ b/tasks/0115_676_115676411_qa_5/task.toml
@@ -0,0 +1,57 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0115_676_115676411_qa_5"
+description = "What percentage of total global sales in the dataset came from the North American (NA) region?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0115/676/115676411.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "49.3%"
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 2
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 2
+memory_mb = 4096
+storage_mb = 10240
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "gregorut__videogamesales"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "gregorut/videogamesales"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "49.25%"
+QUESTION = "What percentage of total global sales in the dataset came from the North American (NA) region?"
+REWARD_MODE = "flexible"
+
+[agent]
+timeout_sec = 900.0
+
+[solution.env]
diff --git a/tasks/0120_687_120687537_qa_5/instruction.md b/tasks/0120_687_120687537_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..97bbe43d85ed4a0ba3b118abb8ef2b4b0c0c990f
--- /dev/null
+++ b/tasks/0120_687_120687537_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average value of the median_income across all samples in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0120_687_120687537_qa_5/task.toml b/tasks/0120_687_120687537_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b50c2584099f2f572946b2275af15b714402fb89
--- /dev/null
+++ b/tasks/0120_687_120687537_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0120_687_120687537_qa_5"
+description = "What is the average value of the median_income across all samples in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0120/687/120687537.ipynb_qa_5"
+kaggle_dataset_name = "camnugent/california-housing-prices"
+gold_answer = "3.870671"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.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 = "3.870671"
+QUESTION = "What is the average value of the median_income across all samples 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/0123_030_123030462_qa_4/instruction.md b/tasks/0123_030_123030462_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..1b1603d86fb7ff01654a18cdfcc9cc336079cc68
--- /dev/null
+++ b/tasks/0123_030_123030462_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:
+Which two features show the strongest negative linear relationship in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0123_030_123030462_qa_4/task.toml b/tasks/0123_030_123030462_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..86a40423e90bcf8c6ba79148d50b487b770e0963
--- /dev/null
+++ b/tasks/0123_030_123030462_qa_4/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0123_030_123030462_qa_4"
+description = "Which two features show the strongest negative linear relationship in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0123/030/123030462.ipynb_qa_4"
+kaggle_dataset_name = "vikrishnan/boston-house-prices"
+gold_answer = "DIS, NOX"
+reward_mode_initial = "list"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "vikrishnan__boston-house-prices"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "vikrishnan/boston-house-prices"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "DIS, NOX"
+QUESTION = "Which two features show the strongest negative linear relationship in the dataset?"
+REWARD_MODE = "flexible"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0126_994_126994091_qa_5/instruction.md b/tasks/0126_994_126994091_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..73f1ea5ea0fe4973c3e2f1a51ff302544d6e9413
--- /dev/null
+++ b/tasks/0126_994_126994091_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):
+- forestfires.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the 75th percentile value of burned area in the original dataset before standardization?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0126_994_126994091_qa_5/task.toml b/tasks/0126_994_126994091_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..639262fbe2f84d2c4c791aab4c4bdad171ef32a9
--- /dev/null
+++ b/tasks/0126_994_126994091_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0126_994_126994091_qa_5"
+description = "What is the 75th percentile value of burned area in the original dataset before standardization?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0126/994/126994091.ipynb_qa_5"
+kaggle_dataset_name = "elikplim/forest-fires-data-set"
+gold_answer = "6.57 hectares"
+reward_mode_initial = "flexible"
+package_tier = 1
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.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__forest-fires-data-set"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "elikplim/forest-fires-data-set"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "6.57 hectares"
+QUESTION = "What is the 75th percentile value of burned area in the original dataset before standardization?"
+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/0128_538_128538835_qa_5/instruction.md b/tasks/0128_538_128538835_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..45c4e8945f4d9ea1717e24c695d250922499a5a2
--- /dev/null
+++ b/tasks/0128_538_128538835_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- (see /home/user/input)
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the average number of comments for Ask HN posts posted at 10: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/0128_538_128538835_qa_5/task.toml b/tasks/0128_538_128538835_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4af0feb5ed2453978801d3e8f01abae845296044
--- /dev/null
+++ b/tasks/0128_538_128538835_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0128_538_128538835_qa_5"
+description = "What is the average number of comments for Ask HN posts posted at 10:00?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0128/538/128538835.ipynb_qa_5"
+kaggle_dataset_name = "hacker-news/hacker-news-posts"
+gold_answer = "10.68"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.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 = "10.68"
+QUESTION = "What is the average number of comments for Ask HN posts posted at 10: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/0132_566_132566728_qa_4/instruction.md b/tasks/0132_566_132566728_qa_4/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..fa449eb5e0fb05f10c65667ee56e0d401743f975
--- /dev/null
+++ b/tasks/0132_566_132566728_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:
+Among the numeric features (tenure, MonthlyCharges, TotalCharges), which variable shows the highest degree of multicollinearity based on VIF 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/0132_566_132566728_qa_4/task.toml b/tasks/0132_566_132566728_qa_4/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..974253007a184e05fe838ca20eb4f3118415fd8b
--- /dev/null
+++ b/tasks/0132_566_132566728_qa_4/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0132_566_132566728_qa_4"
+description = "Among the numeric features (tenure, MonthlyCharges, TotalCharges), which variable shows the highest degree of multicollinearity based on VIF values?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0132/566/132566728.ipynb_qa_4"
+kaggle_dataset_name = "blastchar/telco-customer-churn"
+gold_answer = "TotalCharges"
+reward_mode_initial = "exact_short"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.0
+start_period_sec = 5.0
+start_interval_sec = 2.0
+retries = 30
+
+[environment.env]
+HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all"
+BUCKET_PREFIX = "blastchar__telco-customer-churn"
+HF_TOKEN = "${HF_TOKEN}"
+KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn"
+
+[verifier]
+timeout_sec = 120.0
+
+[verifier.env]
+EXPECTED_ANSWER = "TotalCharges"
+QUESTION = "Among the numeric features (tenure, MonthlyCharges, TotalCharges), which variable shows the highest degree of multicollinearity based on VIF values?"
+REWARD_MODE = "exact_short"
+ATOL = "0.0"
+RTOL = "0.0"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]
diff --git a/tasks/0132_624_132624870_qa_5/instruction.md b/tasks/0132_624_132624870_qa_5/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e6c0230fe87e2802a6d6930f3b803903867d86ff
--- /dev/null
+++ b/tasks/0132_624_132624870_qa_5/instruction.md
@@ -0,0 +1,15 @@
+You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer.
+
+Files (in /home/user/input, no subfolders):
+- vgsales.csv
+
+Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed).
+
+Question:
+What is the difference between the highest North American sales and the highest European sales recorded for video games in the dataset?
+
+Work it out step by step — inspect the data first (head, shape, dtypes), then compute.
+
+Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable
+
+Write only that value to /workdir/answer.txt (e.g. `echo -n "<value>" > /workdir/answer.txt`), then stop.
\ No newline at end of file
diff --git a/tasks/0132_624_132624870_qa_5/task.toml b/tasks/0132_624_132624870_qa_5/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..19696ffa7ee0ee75d1525345d0149d765e852494
--- /dev/null
+++ b/tasks/0132_624_132624870_qa_5/task.toml
@@ -0,0 +1,63 @@
+schema_version = "1.2"
+artifacts = []
+
+[task]
+name = "data-agent-eval-v1/0132_624_132624870_qa_5"
+description = "What is the difference between the highest North American sales and the highest European sales recorded for video games in the dataset?"
+authors = []
+keywords = ["data-agent", "data-analysis", "kaggle"]
+
+[metadata]
+source_dataset = "jupyter-agent/jupyter-agent-dataset"
+source_row_id = "0132/624/132624870.ipynb_qa_5"
+kaggle_dataset_name = "gregorut/videogamesales"
+gold_answer = "12.47"
+reward_mode_initial = "numeric"
+package_tier = 0
+difficulty_level = 0
+
+[environment]
+build_timeout_sec = 600.0
+os = "linux"
+cpus = 1
+memory_mb = 1024
+storage_mb = 5120
+gpus = 0
+allow_internet = true
+mcp_servers = []
+
+# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the
+# agent setup begins. We use it to pull this task's bucket prefix into
+# /home/user/input/. See environment/pull_bucket.py.
+[environment.healthcheck]
+command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]"
+interval_sec = 2.0
+timeout_sec = 180.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 = "12.47"
+QUESTION = "What is the difference between the highest North American sales and the highest European sales recorded for video games in the dataset?"
+REWARD_MODE = "numeric"
+ATOL = "0.05"
+RTOL = "0.01"
+
+[agent]
+# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without
+# cutting off legitimate complex trials. Median Phase B trial is 60-120s;
+# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost
+# certainly a stuck agent loop.
+timeout_sec = 600.0
+
+[solution.env]